> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Hvordan fungerer \expandafter: Fra grunnleggende prinsipper til utforsking av TeXs kildekode [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) ## Innledning Vi har nå dekket bakgrunnstemaene som er nødvendige for en full utforsking av `\expandafter`: * det grunnleggende om TeX-token og hvordan de beregnes; * prinsippene bak TeXs ekspansjonsprosess; * TeXs bruk/opprettelse av midlertidige tokenlister under dokumentbehandling; * hvordan TeX bruker og «jonglerer» flere inndatakilder (inkludert midlertidige tokenlister). I denne artikkelen skal vi samle disse emnene/begrepene for å forklare mekanismene bak TeXs `\expandafter` kommando: kort sagt, hvordan den fungerer. ## Og slik, til \expandafter Ideen bak `\expandafter` er å tvinge frem ekspansjon av en kommando (token) før TeX normalt ville gjøre det. Gitt to token, $$\mathrm{T\_1}$$ og $$\mathrm{T\_2}$$ handlingen til `\expandafter` $$\mathrm{T\_1T\_2}$$ resulterer i at TeX behandler $$\mathrm{T\_1}\text{<}$$ekspansjon av $$\mathrm{T\_2}\text{>}$$, hvor $$\text{<}\dots\text{>}$$ angir en liste med token. TeX ekspanderer $$\mathrm{T\_2}$$ på forhånd slik at token $$\mathrm{T\_1}$$ (f.eks. en primitiv eller en makro) får se, eller kan virke på, tokenene som oppstår fra ekspansjonen av $$\mathrm{T\_2}$$. Hvis tokenet $$\mathrm{T\_2}$$ representerer et ikke-ekspanderbart element som for eksempel en ikke-aktiv karakter eller (de fleste) primitiver, vil handlingen til `\expandafter` endrer ingenting: TeX ville fortsette å behandle token $$\mathrm{T\_1T\_2}$$ på normal måte. ### Introduksjon til bruk av \expandafter Hvis du ikke har brukt `\expandafter`, her er et eksempel på bruk med den primitiven `\uppercase{...}`. Anta at vi ønsker å sette navnet på vår hoved- `.tex` inndatafil, men med store bokstaver. Vi kjenner kanskje til følgende primitivkommandoer i TeX: * `\uppercase`: gjør som navnet tilsier, konverterer tegn-token til deres ekvivalent i store bokstaver (der det finnes); * `\jobname`: som vi har sett, ekspanderer til å gi navnet på hoved- `.tex` filen. Hvis TeX-filen vår heter `mycode.tex` kan vi med rimelighet forvente `\uppercase{\jobname}` å sette `MYCODE`. Men nei, den setter `mycode` som små bokstaver. Hva gikk «galt»? Hvis vi skriver den generelle bruken av `\uppercase` som ``` \uppercase{} ``` kan vi si at `\uppercase` ser gjennom `` og vil bare operere (endre case) på *tegn-token* den oppdager innen ``: alle ikke-tegn-token blir *ignorert* fordi `\uppercase` ikke vil «se inn i» (ekspandere) ikke-tegn-token for å se hva de inneholder eller representerer. Fordi et token ganske enkelt er en heltallsverdi, er alt `\uppercase` må gjøre å se gjennom tokenlisten for å sjekke om den numeriske verdien til hvert token i `` faller innenfor området av verdier som indikerer et tegn-token. Forresten, `\uppercase` vil også *endre store/små bokstaver på aktive tegn* for å lage et aktivt tegn i store bokstaver som, fordi det fortsatt er aktivt, også må være definert, ellers vil TeX generere en feil: `Udefinert kontrollsekvens`, men vi avsporer... For eksempel, selv om vi definerer en makro som bare er tekst ``` \def\foo{some lower-case text} ``` så `\uppercase{\foo}` fortsatt ut som `some lower-case text` og ikke `SOME LOWER-CASE TEXT` som vi skulle håpe, rett og slett fordi handlingen til `\uppercase` ikke prøver å fastslå hva `\foo` representerer: den ser `\foo` som et kommandotoken og ignorerer det, slik den gjorde med `\jobname`. ### Hvordan kan vi fikse dette? \expandafter til unnsetning For å sette en versjon av filnavnet i store bokstaver, må vi endre `\uppercase{\jobname}` ved å tvinge TeX til å erstatte `\jobname` med ekspansjonen dens (en sekvens av tegn-token) *før* `\uppercase` får virke. Nok en gang brukes ekspansjon til å fjerne `\jobname` tokenet (kommandoen) og erstatte det med resultatet av ekspansjonen (en tokenliste som inneholder tegn-token). Så hvis vi skriver ``` \uppercase\expandafter{\jobname} ``` så fungerer det: `MYCODE` ville bli satt. Det som skjer er at TeX begynner å behandle `\uppercase` og sjekker umiddelbart etter den obligatoriske åpne klammeparentesen (`{`); men TeX oppdager en `\expandafter` kommando som får den til midlertidig å «rette oppmerksomheten» mot å behandle `\expandafter{\jobname}`. Hvis vi sammenligner `\expandafter` $$\mathrm{T\_1T\_2}$$ med vårt eksempel `\expandafter{\jobname}` kan vi se * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Hvor `{`token og `\jobname`token viser til tokenverdiene beregnet av TeX—indeksnotasjonen token brukes for å minne oss selv på at TeX arbeider i en verden av heltallstoken. Å skrive `\uppercase\expandafter{\jobname}` fungerer fordi, grovt sett (detaljer følger), `\expandafter` får TeX til å utføre følgende oppgaver: 1. les og lagre den åpne `{`token; 2. les neste token: `\jobname`token. TeX erkjenner at `\jobname`token representerer en ekspanderbar kommando og ekspanderer den. `\jobname`token blir erstattet med ekspansjonen sin—en serie tegn-token; 3. etter å ha ekspandert `\jobname` kommandoen, legger TeX `{`$$\_\mathrm{token}$$ «tilbake i inndata» og bruker tokenlisten som oppstår fra ekspansjonen av `\jobname` slik at TeX vil lese `\uppercase{`token``tokenliste (tegn)`}`, og dette gir det ønskede resultatet. Følgende diagram viser hvordan TeX behandler `\uppercase\expandafter{\jobname}`—les grafikken nedenfra og arbeid oppover for å følge prosessflyten. ![Hvordan \expandafter fungerer](/files/b8dc033d467b6aa376292cb5fef84559698dc871) Følgende notater forklarer de ulike behandlingsstadiene. 1. TeX begynner å behandle `\uppercase` og sjekker etter den obligatoriske åpne klammeparentesen (`{`) men oppdager en `\expandafter` kommandoen. 2. Hvis vi sammenligner `\expandafter` $$\mathrm{T\_1T\_2}$$ til inndataen vår til `\expandafter{\jobname}` kan vi se $$\mathrm{T\_1} =$$`{`token og $$\mathrm{T\_2} =$$`\jobname`token. Merk at vi her vil bruke indeks token for å angi at TeX behandler heltalls-tokenverdier. 3. `\expandafter` leser, og lagrer deretter midlertidig, den `{`token ved å lagre den heltalls-tokenverdien i en intern variabel. Senere vil TeX sette inn det tokenet tilbake i inndataen, etter å ha behandlet `\jobname` kommandoen. 4. `\expandafter` leser neste token, `\jobname`token, og ekspanderer `\jobname` kommandoen. 5. Ekspansjonen av `\jobname` oppretter en midlertidig tokenliste som inneholder en sekvens av tegn-token som representerer `.tex` filnavnet. Merk at alle tegn-token som genereres av `\jobname` beregnes med kategoriode 12. 6. Når `\jobname` er blitt ekspandert, setter TeX inn igjen tokenet som ble lagret i steg 3 (`{`token) og legger det tilbake i inndataen. TeX gjør det ved å opprette en ny tokenliste som inneholder den *enkle* `{`token 7. TeX har nå fullført behandlingen av `\expandafter`, noe som resulterer i to tokenlister klare til å brukes som kilder til TeX-inndata. TeX går nå tilbake til å behandle `\uppercase` men har konfigurert inndataen sin slik at de to tokenlistene opprettet av `\expandafter` blir kilden til token for `\uppercase`—som nå ser `\uppercase{`token``tokenliste (tegn)`}`. `\uppercase` ser nå en sekvens av tegn-token og kan produsere det ønskede resultatet. 8. Etter å ha lest alle tegn-tokenene produsert av `\jobname`, går TeX tilbake til å hente token fra sin forrige inndatakilde (vår `.tex` fil) derfra vil den lese neste token: den avsluttende `}` som kreves for å avslutte listen av token som skal behandles av `\uppercase`. ### \expandafter og interne tokenlister Midlertidige tokenlister er et *avgjørende* element i `\expandafter`s behandlingsatferd: å forstå bruken og eksistensen av disse tokenlistene kan bidra til å klargjøre hvordan `\expandafter` oppnår resultatene sine, spesielt når man prøver å skrive, eller forstå, makroer som bruker flere påfølgende `\expandafter` kommandoer for å oppnå mer komplekse former for tokenbehandling: `\expandafter\expandafter\expandafter...` Et annet nøkkelelement i `\expandafter`s atferd, særlig med flere påfølgende `\expandafter` kommandoer, er bruken av *rekursjon* (inne i selve TeX-programvaren)—et tema vi vil vurdere senere i denne artikkelen. For å videre hjelpe vår forståelse av midlertidige tokenlister skal vi se på ett eksempel til av `\expandafter`, denne gangen med `\the` kommandoen. #### \expandafter og interne tokenlister: eksempel 2 I dette eksemplet skal vi se hvordan `\expandafter` kan brukes til å påvirke token lagret i en tokenregister via `\toks` kommandoen. Her er TeX-primitivene vi skal bruke: * `**\count** *register*=*tall*`: en TeX-primitiv brukt til å lagre verdien `*tall*` i TeX-plasseringen `*register*`; * `**\toks** *register*={*tokenliste*}`: en TeX-primitiv brukt til å lagre `*tokenliste*` i tokenregisterplasseringen `*register*`—lagring av en sekvens av token for senere bruk; * `**\the** *token*`: en ekspanderbar TeX-primitivkommando som behandler `*token*`, selv om de nøyaktige resultatene avhenger av arten til `*token*` som behandles. `\the` har en rekke bruksområder: blant annet å sette verdien som er lagret i en TeX-parameter eller variabel (f.eks. et register). Andre bruksområder for `\the` inkluderer å sette inn en kopi av token lagret i et tokenregister. Her skal vi bruke `\the` til å sette verdien lagret i et `\count` register. Vi begynner med følgende TeX-kode for å lagre verdien `12345` i TeXs `\count` register `99`: ``` \count99=12345 ``` Hvis vi vil sette verdien lagret i `\count99` kan vi bruke `\the\count99` (eller `\number\count99`). Deretter bruker vi `\toks` kommandoen til å lagre noen token i tokenregister `99`: ``` \toks99={\the\count99 } ``` Tokenlisten lagret i tokenregister `99` ville inneholde følgende: | | | | ------------------ | ------------------------------------------------------------------------------------------------------ | | **TeX-tokenverdi** | **Representert element** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (tegnkode 57 med kategoriode 12) som gir en tokenverdi på $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (tegnkode 57 med kategoriode 12), som gir en tokenverdi på $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (tegnkode 32 med kategoriode 10), som gir en tokenverdi på $$256 \times 10 + 32 = 2592$$ | Merk at tokenlisten opprettet av `\toks99` ikke *inneholder* den faktiske dataverdien lagret i `\count99` fordi `\toks` kommandoen ikke utfører ekspansjon: den oppretter ganske enkelt token og lagrer dem. I vårt eksempel, `\the` er ikke ekspandert, så den behandler ikke `\count99`; her `\the` er bare gjort om til et token (verdi 5382) og lagret i tokenlisten. Hvis vi ønsker at `\toks99` tokenlisten skal inneholde token som representerer data lagret i `\count99` vil vi trenge en måte å opprette disse tokenene (gjøre dem tilgjengelige) på, slik at `\toks` kommandoen kan få tilgang til dem. Og selvfølgelig `\expandafter` kan gjøre dette for oss. Hvis vi skriver: ``` \toks99=\expandafter{\the\count99 } ``` handlingen/behandlingen av `\toks` kommandoen vil bli «satt på vent» mens `\expandafter` får (tvinger) ekspansjon av `\the` som igjen virker på `\count` for å generere en midlertidig tokenliste som inneholder tegn-token som representerer data lagret i `\count99`. Et lite, men viktig poeng er `` tegnet etter sifrene `99`: det `` tegnet virker til å avslutte TeXs skanningsprosess når den leter etter en numerisk størrelse. Her er handlingen til `\expandafter` svært lik `\jobname` eksemplet. 1. Les og lagre den åpne `{`token. 2. Les neste token, `\the`token, som representerer en ekspanderbar kommando, så TeX ekspanderer den. `\expandafter` tvinger frem ekspansjon av `\the` som deretter virker på `\count99` for å konvertere data lagret i `\count` register `99` (tallet 12345) til en midlertidig tokenliste. Den listen vil inneholde tegn-token som representerer sifrene `1`, `2`, `3`, `4` og `5`—tegn-token med kategoriode 12. 3. Etter å ha ekspandert og behandlet `\the`, legger TeX `{`token «tilbake i inndata» og bruker tokenlisten som oppstår fra `\the\count99` slik at TeX vil lese `\toks99={`token``tokenliste (tegn)`}` og dette gir det ønskede resultatet. Denne sekvensen av hendelser er oppsummert i følgende diagram—les grafikken nedenfra og arbeid oppover for å følge prosessflyten. ![Hvordan \expandafter fungerer](/files/7486b9011a7e93c6af9756a340857ca08b10852e) 1. TeX begynner å behandle `\toks`; den ser det valgfrie `=` tegnet, og sjekker deretter etter den obligatoriske åpne klammeparentesen (`{`, eller et hvilket som helst tegn med kategoriode 1) som brukes til å angi starten på en tokenliste. TeX oppdager imidlertid en `\expandafter` kommando og går videre til å utføre den i stedet. 2. Hvis vi sammenligner `\expandafter` $$\mathrm{T\_1T\_2}$$ til inndataen vår til `\expandafter{\the\count99 }` kan vi se $$\mathrm{T\_1} =$$ `{`token og $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` leser, og lagrer deretter midlertidig, den `{`token (TeX lagrer midlertidig den heltalls-tokenverdien i en intern variabel). Senere vil TeX sette det tokenet tilbake i inndataen, etter å ha behandlet `\the` 4. `\expandafter` leser neste token, `\the`token og ekspanderer den. 5. Ekspansjonen av `\the` oppretter en midlertidig tokenliste fra behandlingen av `\count99`—den tokenlisten inneholder en sekvens av tegn-token som representerer dataverdien lagret i `\count` register `99`. 6. Når `\the` er blitt ekspandert, setter TeX inn igjen tokenet som ble lagret i steg 3 (`{`token) og legger det tokenet tilbake i inndataen. TeX gjør det ved å opprette en annen tokenliste som inneholder den *enkle* token `{`token. 7. TeX har nå fullført behandlingen av `\expandafter` og produserte to tokenlister klare til å brukes som neste inndatakilder. TeX går tilbake til å behandle `\toks99=` men nå har TeX konfigurert inndataen slik at de to tokenlistene opprettet av `\expandafter` blir kilden til token for `\toks`—som nå ser `{`token``tokenliste (tegn)`}`. `\toks` kan nå få tilgang til, og lagre, sekvensen av 5 tegn-token som representerer dataverdien (`12345`) lagret i `\count99`: vårt ønskede resultat. 8. Etter å ha lest alle tegn-tokenene produsert av `\the\count99`, går TeX tilbake til å hente token fra sin forrige inndatakilde (vår `.tex` fil) derfra vil den lese neste token: den avsluttende `}` som kreves for å avslutte listen av token som skal lagres av `\toks99={...}`. ## Hvordan \expandafter egentlig fungerer I denne delen skal vi ta en «lavnivå»-kikk inn i selve TeX: utforske kildekoden/funksjonene i TeX som implementerer atferden til `\expandafter`. Detaljene uttrykkes i pseudo-C-kode, men bør være tilgjengelige for alle som er kjent med andre programmeringsspråk. Følgende kommenterte diagram forklarer hvordan TeX implementerer `\expandafter` som en del av en større funksjon kalt `expand()`—kjernefunksjonen som driver TeXs ekspansjonsbehandling. Innenfor delen som er ansvarlig for å implementere `\expandafter` kan vi se [*rekursive* atferden](https://en.wikipedia.org/wiki/Recursion) der et annet kall til `expand()` funksjonen brukes til å behandle det andre tokenet som ble lest inn, $$\mathrm{T\_2}$$, for de tilfellene hvor $$\mathrm{T\_2}$$ er ekspanderbar. Selv om denne koden forekommer i Knuths TeX-motor, er de grunnleggende prinsippene som skisseres av denne grafikken anvendelige for alle TeX-motorer. ![Hvordan \expandafter fungerer inne i TeX](/files/6af59116d59dbfe3c1fbd7568e751d8cc21283dd) Den første oppgaven til `expand()` er å avgjøre om kommandoen som skal ekspanderes er en makro eller en primitiv, fordi makroer har en spesialisert ekspansjonsprosess som håndteres av en funksjon kalt `macrocall()`. Hvis kommandoen som skal ekspanderes er en primitiv, bruker `expand()` funksjonen den gjeldende kommandokodeverdien (lagret i global variabel `curcmd`) for å identifisere hvilken bestemt primitiv som må behandles. Vi kan se disse detaljene i en mer fullstendig liste av `expand()`: ``` void expand(void) { //curcmd er en global variabel if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Behandle \expandafter T1T2-kommandoen { gettoken(); // Les token T1 t = curtok; // Lagre token T1 i lokal variabel t gettoken(); // Les token T2 if(curcmd > 100) // Er token T2 utvidbar? expand(); // Ja! T2 er utvidbar: // utfør utvidelse av T2 ved å // gjøre et rekursivt funksjonskall til expand() else backinput(); // T2 er ikke utvidbar: legg den tokenen // tilbake i inputen slik at den kan leses igjen (senere) curtok = t ; // Gjenopprett den globale variabelen curtok til den lagrede verdien til T1 backinput() ; // Legg token T1 tilbake i inputen // foran tokenene som oppstår fra utvidelsen av T2 } break; // Kode for å behandle andre utvidbare kommandoer case “konverter til tekst”-kommando: // En hvilken som helst av \number, \string, \romannumeral, // \meaning, \fontname, \jobname // De deler samme verdi av curcmd break; case \noexpand: // Undertrykk utvidelsen av neste token ... break; case \csname: // Lag et kontrollsekvensnavn. ... break; case \the: // Sett inn noen token .... break; case “\if... testkommando” : // Behandle en av TeXs 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”: // Avslutt den gjeldende betingelsen ... break; // osv. for alle andre utvidbare primitive kommandoer som støttes av // TeX-motoren } }else // Ikke en utvidbar primitiv: det er en makro { macrocall() } //... mer kode er fjernet } ``` ### TeXs forkjærlighet for globale variabler Kanskje som et uttrykk for alderen og tiden det ble designet i, bruker TeXs kildekode i stor utstrekning såkalte [globale variabler](https://en.wikipedia.org/wiki/Global_variable)—faktisk er det hundrevis av dem. Per definisjon kan globale variabler endres/modifiseres fra hvor som helst i TeXs kildekode — som for Knuths TeX er én monolitisk fil med over 25 000 linjer kode og hundrevis av funksjoner. Å forstå hvordan TeX fungerer er ikke alltid en enkel oppgave... For å behandle `\expandafter`, leser TeX token fra sin gjeldende input ved hjelp av en funksjon kalt `gettoken()` hvis oppgave er å opprette et token og sette verdien av flere viktige globale variabler som brukes gjennom hele TeXs kildekode. To slike variabler, som oppdateres av handlingen til `gettoken()`, brukes i implementeringen av `\expandafter`: * `curtok`: (gjeldende token) heltallsverdien til tokenet som nettopp ble lest inn; * `curcmd`: (gjeldende kommandokode) kommandokoden til kommandoen (eller tegnet) som representeres av tokenet `curtok`. Når man behandler `\expandafter`$$\mathrm{T\_1T\_2}$$ TeX leser token $$\mathrm{T\_1}$$ og lagrer midlertidig verdien (et heltall) i en lokal variabel kalt `t`. Deretter leser TeX $$\mathrm{T\_2}$$ og sjekker om det tokenet representerer en utvidbar kommando—ved å sjekke om kommandokoden (`curcmd`) er > 100. Hvis så, må TeX utvide kommandoen representert av $$\mathrm{T\_2}$$ og gjør enda et kall til funksjonen `expand()`: dette er et eksempel på *rekursjon* fordi `expand()` at funksjonen kaller seg selv. Bevissthet om den rekursive naturen til utvidelse, spesielt når man bruker `\expandafter`, kan hjelpe med å forstå hvordan flere påfølgende `\expandafter` kommandoer—dvs., `\expandafter\expandafter\expandafter...` oppnår virkningene sine. Hvis token $$\mathrm{T\_2}$$ er utvidbar, finner utvidelsen sted, og når det rekursive kallet til `expand()` returnerer, vil kode i implementeringen av `\expandafter` setter token $$\mathrm{T\_1}$$ tilbake i inputen. Den globale variabelen `curtok` tilordnes på nytt verdien av det lagrede tokenet—lagret i den lokale variabelen `t`, som er verdien til token $$\mathrm{T\_1}$$—og det gjøres et kall til funksjonen `backinput().` #### Funksjonen backinput() Som navnet tilsier, legger denne funksjonen et token «tilbake i inputen». For å gjøre det bruker TeX den nåværende verdien av den globale variabelen `curtok` for å opprette en tokenliste som inneholder ett enkelt token (hvis heltallsverdi leveres av `curtok`). TeX organiserer også innhåndteringen slik at den enkelt-token-listen på riktig tidspunkt blir lest på nytt av TeX som en del av den påfølgende inputbehandlingen. Merk nøye at tokenet $$\mathrm{T\_1}$$ settes inn igjen *etter at utvidelsen er fullført*, noe som sikrer at TeX vil lese det gjeninnsatte tokenet *før* når det leser tokenene som oppstår fra utvidelsen av $$\mathrm{T\_2}$$. ### Behandling av makroer: funksjonen macrocall() Som tidligere diskutert er alle makroer, sammen med noen primitive kommandoer, utvidbare, og all utvidelsesbehandling går gjennom `expand()` funksjonen. Men `expand()` er nøye med å bruke `curcmd` (gjeldende kommando)-verdien for å skille mellom utvidbare primitiver og makroer, fordi makroudvidelsesprosessen håndteres av en egen funksjon kalt `macrocall()`. Makroer trenger en spesialisert utvidelsesprosess fordi makroargumenter og skilletegn-token må letes etter på en svært bestemt og rigorøs måte; følgelig delegeres den prosessen til en funksjon utviklet for nettopp det: `macrocall()`. #### Makroudvidelse vs. makrokjøring Makro *utvidelse* er ikke den samme prosessen som makro *kjøring*: utvidelse av en makro er forberedelsesprosessen TeX utfører for å gjøre makroen *klar for kjøring*. «Kjøringen» av en makro skjer når TeX aktivt leser og behandler tokenene som finnes i den makroens definisjon (erstatningstekst) og dens argumenter (parametere). #### Makroudvidelse For å utvide en makro sjekker TeX først om makroen tar argumenter; hvis ja, `macrocall()` skanner TeX svært nøye inputen på jakt etter token som er ment å bli makroens argumenter. Den prosessen inkluderer å kontrollere brukerens input for eventuelle skilletegn-token som brukes i makroens opprinnelige definisjon—mønsteret av token brukt i et makrokall må nøyaktig samsvare med mønsteret av token i den lagrede definisjonen. Token brukt som skilletegn blir imidlertid bare forkastet av TeX: de er i praksis bare en form for «tegnsetting» som TeX bruker for å bestemme de faktiske tokenene som er ment å bli makroens argumenter—dvs. token brukeren har ment skal behandles av makroen. For mer informasjon om skilletegn-token, se [Hvordan TeX-makroer faktisk fungerer](/latex/no/flere-emner/22-how-tex-macros-actually-work-part-4.md). For hver parameter (`#1, #2...#9`) som finnes i makroens opprinnelige definisjon, skanner TeX det faktiske makrokallet for å identifisere hvilke token som er levert av brukeren og er ment for hver parameter (dvs. utgjør makroens argumenter). Den prosessen produserer én eller flere små tokenlister: én for hvert makroargument. Etter at eventuelle makroargumenter er blitt oppdaget og tokenlistene deres er forberedt, henter TeX makroens definisjon (erstatningstekst) lagret i minnet og ordner inputbehandlingen slik at når TeX er klar til å lese/behandle flere token, vil den lese dem fra makroens erstatningstekst, og dermed kjøre makroen. På det rette tidspunktet, under makrokjøringen, vil tokenlister som representerer makroargumentene bli ført inn på riktig sted i makroens erstatningstekst. Igjen betyr utvidelse av en makrokommando *å fjerne* den makrokommandoen (tokenet) fra inputen og *å erstatte* det med tokenlisten som er lagret som makroens erstatningstekst. For et grundig innblikk i TeXs makrobehandling, se den seksdelte artikkelserien [Hvordan fungerer TeX-makroer egentlig?](/latex/no/flere-emner/01-a-six-part-series-how-do-tex-macros-actually-work.md) [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/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.