> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Hur fungerar \expandafter: från grundläggande principer till att utforska TeX:s källkod [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) ## Introduktion Vi har nu gått igenom bakgrundsämnena som behövs för en fullständig genomgång av `\expandafter`: * grunderna för TeX-token och hur de beräknas; * principerna bakom TeX:s expansionsprocess; * TeX:s användning/skapande av tillfälliga tokenlistor under dokumentbearbetning; * hur TeX använder och “jonglerar” med flera inmatningskällor (inklusive tillfälliga tokenlistor). I den här artikeln kommer vi att föra samman dessa ämnen/begrepp för att förklara mekanismerna bakom TeX:s `\expandafter` kommando: kort sagt, hur det fungerar. ## Och så, till \expandafter Idén bakom `\expandafter` är att tvinga fram expansion av ett kommando (token) innan TeX normalt skulle göra det. Givet två token, $$\mathrm{T\_1}$$ och $$\mathrm{T\_2}$$ handlingen med `\expandafter` $$\mathrm{T\_1T\_2}$$ resulterar i att TeX bearbetar $$\mathrm{T\_1}\text{<}$$expansion av $$\mathrm{T\_2}\text{>}$$, där $$\text{<}\dots\text{>}$$ betecknar en lista med token. TeX expanderar $$\mathrm{T\_2}$$ i förväg så att token $$\mathrm{T\_1}$$ (t.ex. en primitiv eller en makro) får se, eller kan agera på, de token som uppstår genom expansion av $$\mathrm{T\_2}$$. Om token $$\mathrm{T\_2}$$ representerar något oexpanderbart, såsom ett icke-aktivt tecken eller de flesta primitiver, så ändrar handlingen med `\expandafter` ingenting: TeX skulle fortsätta att bearbeta token $$\mathrm{T\_1T\_2}$$ på normalt sätt. ### Introduktion till att använda \expandafter Om du inte har använt `\expandafter`, här är ett exempel som använder det med den primitiva `\uppercase{...}`. Anta att vi vill sätta namnet på vår huvudsakliga `.tex` inmatningsfil med versaler. Vi kanske känner till följande primitiva TeX-kommandon: * `\uppercase`: gör som namnet antyder, omvandlar teckentoken till deras motsvarighet i versaler (där en sådan finns); * `\jobname`: som vi har sett, expanderar till namnet på huvud `.tex` -filen. Anta att vår TeX-fil heter `mycode.tex` vi skulle rimligen kunna förvänta oss `\uppercase{\jobname}` att sätta `MYCODE`. Men nej, den sätter `mycode` med gemener. Vad gick “fel”? Om vi skriver den allmänna användningen av `\uppercase` som ``` \uppercase{} ``` kan vi säga att `\uppercase` tittar igenom `` och kommer endast att tillämpa (ändra skiftläge på) *teckentoken* den upptäcker inom ``: alla icke-teckentoken *ignoreras* eftersom `\uppercase` inte kommer att “titta in i” (expandera) icke-teckentoken för att se vad de innehåller eller representerar. Eftersom en token helt enkelt är ett heltalsvärde, behöver `\uppercase` bara titta igenom tokenlistan för att kontrollera om det numeriska värdet för varje token i `` ligger inom intervallet av värden som anger en teckentoken. För övrigt, `\uppercase` kommer också att *ändra skiftläge på aktiva tecken* för att skapa ett aktivt versaltecken, vilket, eftersom det fortfarande är aktivt, också måste ha definierats; annars kommer TeX att generera ett fel: `Odefinierad kontrollsekvens`, men vi avviker... Till exempel, även om vi definierar ett makro som bara är text ``` \def\foo{some lower-case text} ``` så `\uppercase{\foo}` sätter fortfarande `some lower-case text` och inte `SOME LOWER-CASE TEXT` som vi skulle hoppas, helt enkelt eftersom handlingen med `\uppercase` inte försöker avgöra vad `\foo` representerar: den ser `\foo` som en kommandotoken och ignorerar den, precis som den gjorde med `\jobname`. ### Hur kan vi fixa detta? \expandafter till undsättning För att sätta en versal version av filnamnet behöver vi modifiera `\uppercase{\jobname}` genom att tvinga TeX att ersätta `\jobname` med dess expansion (en sekvens av teckentoken) *innan* `\uppercase` börjar arbeta. Återigen används expansion för att ta bort `\jobname` tokenen (kommandot) och ersätta den med resultatet av dess expansion (en tokenlista som innehåller teckentoken). Så, om vi skriver ``` \uppercase\expandafter{\jobname} ``` så fungerar det: `MYCODE` skulle sättas. Det som händer är att TeX börjar bearbeta `\uppercase` och kontrollerar omedelbart den obligatoriska öppnande klammerparentesen (`{`); men TeX upptäcker ett `\expandafter` kommando som gör att det tillfälligt “dirigerar om sin uppmärksamhet” till att bearbeta `\expandafter{\jobname}`. Om vi jämför `\expandafter` $$\mathrm{T\_1T\_2}$$ med vårt exempel `\expandafter{\jobname}` kan vi se * $$\mathrm{T\_1} =\space$$`{`token * $$\mathrm{T\_2} =\space$$`\jobname`token Där `{`token och `\jobname`token avser tokenvärdena beräknade av TeX—indexnotationen token används för att påminna oss om att TeX arbetar i världen av heltalstoken. Att skriva `\uppercase\expandafter{\jobname}` fungerar eftersom, i grova drag (detaljer följer), `\expandafter` får TeX att utföra följande uppgifter: 1. läsa och spara den öppnande `{`token; 2. läs nästa token: `\jobname`token. TeX känner igen att `\jobname`token representerar ett expanderbart kommando och expanderar det. `\jobname`token ersätts med dess expansion—en serie teckentoken; 3. efter att ha expanderat `\jobname` kommandot, lägger TeX tillbaka `{`$$\_\mathrm{token}$$ “tillbaka i indata” och använder tokenlistan som uppstår ur expansionen av `\jobname` så att TeX kommer att läsa `\uppercase{`token``tokenlista (tecken)`}`, och detta ger det resultat vi vill ha. Följande diagram visar hur TeX bearbetar `\uppercase\expandafter{\jobname}`—läs grafiken nerifrån och arbeta uppåt för att följa processflödet. ![Hur \expandafter fungerar](/files/663fe8204f33e3a5c4b723227ffc64d8de6caafb) Följande anteckningar förklarar de olika bearbetningsstegen. 1. TeX börjar bearbeta `\uppercase` och kontrollerar den obligatoriska öppnande klammerparentesen (`{`) men upptäcker en `\expandafter` kommandot. 2. Om vi jämför `\expandafter` $$\mathrm{T\_1T\_2}$$ till vår inmatning av `\expandafter{\jobname}` kan vi se $$\mathrm{T\_1} =$$`{`token och $$\mathrm{T\_2} =$$`\jobname`token. Observera att vi här kommer att använda indexet token för att indikera att TeX bearbetar heltalstokenvärden. 3. `\expandafter` läser, och sparar sedan tillfälligt, den `{`token genom att lagra det heltals-tokenvärdet i en intern variabel. Senare kommer TeX att infoga tillbaka den tokenen i indata efter att ha bearbetat `\jobname` kommandot. 4. `\expandafter` läser nästa token, `\jobname`token, och expanderar `\jobname` kommandot. 5. Expansionen av `\jobname` skapar en tillfällig tokenlista som innehåller en sekvens av teckentoken som representerar `.tex` filnamnet. Observera att alla teckentoken som genereras av `\jobname` beräknas med kategorikod 12. 6. När `\jobname` har expanderats, infogar TeX tillbaka tokenen som sparades i steg 3 (`{`token) och lägger tillbaka den i indata. TeX gör detta genom att skapa en annan tokenlista som innehåller den *enda* `{`token 7. TeX har nu avslutat bearbetningen av `\expandafter`, vilket resulterar i två tokenlistor redo att användas som källor för TeX-indata. TeX går nu tillbaka till att bearbeta `\uppercase` men har konfigurerat sin indata så att de två tokenlistor som skapats av `\expandafter` blir tokenkällan för `\uppercase`—som nu ser `\uppercase{`token``tokenlista (tecken)`}`. `\uppercase` nu ser en sekvens av teckentoken och kan producera vårt önskade resultat. 8. Efter att ha läst alla teckentoken som producerats av `\jobname`, återgår TeX till att hämta token från sin tidigare indatakälla (vår `.tex` fil) därifrån kommer den att läsa nästa token: den avslutande `}` som krävs för att avsluta listan av token som ska bearbetas av `\uppercase`. ### \expandafter och interna tokenlistor Tillfälliga tokenlistor är en *avgörande* del av `\expandafter`:s bearbetningsbeteende: att förstå användningen och existensen av dessa tokenlistor kan hjälpa till att klargöra hur `\expandafter` uppnår sina resultat, särskilt när man försöker skriva, eller förstå, makron som använder flera efterföljande `\expandafter` kommandon för att uppnå mer komplexa former av tokenbearbetning: `\expandafter\expandafter\expandafter...` Ett annat viktigt element i `\expandafter`:s beteende, särskilt med flera efterföljande `\expandafter` kommandon, är användningen av *rekursion* (inuti TeX-programvaran själv)—ett ämne vi kommer att ta upp senare i artikeln. För att ytterligare hjälpa vår förståelse av tillfälliga tokenlistor kommer vi att titta på ytterligare ett exempel på `\expandafter`, denna gång med `\the` kommandot. #### \expandafter och interna tokenlistor: exempel 2 I det här exemplet kommer vi att se hur `\expandafter` kan användas för att påverka token som lagras i ett tokenregister via `\toks` kommandot. Här är de TeX-primitiver vi kommer att använda: * `**\count** *register*=*tal*`: en TeX-primitiv som används för att lagra värdet `*tal*` i TeX-positionen `*register*`; * `**\toks** *register*={*tokenlista*}`: en TeX-primitiv som används för att lagra `*tokenlista*` i tokenregisterpositionen `*register*`—spara en sekvens av token för senare användning; * `**\the** *token*`: ett expanderbart TeX-primitivkommando som bearbetar `*token*`, även om de exakta resultaten beror på arten hos den `*token*` som bearbetas. `\the` har ett antal användningsområden: bland dem finns att sätta värdet som lagras i en TeX-parameter eller variabel (t.ex. ett register). Andra användningar av `\the` inkluderar att infoga en kopia av token som lagras i ett tokenregister. Här kommer vi att använda `\the` för att sätta värdet som lagras i en `\count` register. Vi börjar med följande TeX-kod för att lagra värdet `12345` i TeX:s `\count` register `99`: ``` \count99=12345 ``` Om vi vill sätta värdet som lagras i `\count99` kan vi använda `\the\count99` (eller `\number\count99`). Därefter kommer vi att använda `\toks` kommandot för att lagra några token i tokenregister `99`: ``` \toks99={\the\count99 } ``` Tokenlistan som lagras i tokenregistret `99` skulle innehålla följande: | | | | ------------------ | --------------------------------------------------------------------------------------------------------------------- | | **TeX-tokenvärde** | **Objekt som representeras** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (teckenkod 57 med kategorikod 12) vilket resulterar i ett tokenvärde på $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (teckenkod 57 med kategorikod 12), vilket resulterar i ett tokenvärde på $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (teckenkod 32 med kategorikod 10), vilket resulterar i ett tokenvärde på $$256 \times 10 + 32 = 2592$$ | Observera att tokenlistan som skapas av `\toks99` gör *inte* innehåller det faktiska datavärde som lagras i `\count99` eftersom `\toks` kommandot inte utför expansion: det skapar helt enkelt token och lagrar dem. I vårt exempel, `\the` expanderas inte så den bearbetar inte `\count99`; här `\the` omvandlas bara till en token (värde 5382) och lagras i tokenlistan. Om vi vill att `\toks99` tokenlistan ska innehålla token som representerar data lagrade i `\count99` kommer vi att behöva något sätt att skapa dessa token (göra dem tillgängliga) så att `\toks` kommandot kan komma åt dem. Och naturligtvis `\expandafter` kan göra detta åt oss. Om vi skriver: ``` \toks99=\expandafter{\the\count99 } ``` kommer handlingen/bearbetningen av `\toks` kommandot att “hållas tillbaka” medan `\expandafter` orsakar (tvingar fram) expansion av `\the` som i sin tur verkar på `\count` för att generera en tillfällig tokenlista som innehåller teckentoken som representerar data lagrade i `\count99`. En liten men viktig punkt är `` mellanslagstecknet efter siffrorna `99`: det `` tecknet fungerar som avslutning för TeX:s avsökningsprocess när den söker efter en numerisk mängd. Här är handlingen med `\expandafter` mycket lik `\jobname` -exemplet. 1. Läs och spara den öppnande `{`token. 2. Läs nästa token, `\the`token, som representerar ett expanderbart kommando, så TeX expanderar det. `\expandafter` tvingar fram expansion av `\the` som sedan verkar på `\count99` för att omvandla data lagrade i `\count` register `99` (talet 12345) till en tillfällig tokenlista. Den listan kommer att innehålla teckentoken som representerar siffrorna `1`, `2`, `3`, `4` och `5`—teckentoken med kategorikod 12. 3. Efter att ha expanderat och bearbetat `\the`, lägger TeX tillbaka `{`token “tillbaka i indata” och använder tokenlistan som uppstår från `\the\count99` så att TeX kommer att läsa `\toks99={`token``tokenlista (tecken)`}` och detta ger det resultat vi vill ha. Denna sekvens av händelser sammanfattas i följande diagram—läs grafiken nerifrån och arbeta uppåt för att följa processflödet. ![Hur \expandafter fungerar](/files/13c87988ad7fa53a4917c212fdd5a933179aac01) 1. TeX börjar bearbeta `\toks`; den ser det valfria `=` tecknet, därefter kontrollerar den den obligatoriska öppnande klammerparentesen (`{`, eller vilket tecken som helst med kategorikod 1) som används för att ange början av en tokenlista. Men TeX upptäcker ett `\expandafter` kommando och fortsätter att utföra det i stället. 2. Om vi jämför `\expandafter` $$\mathrm{T\_1T\_2}$$ till vår inmatning av `\expandafter{\the\count99 }` kan vi se $$\mathrm{T\_1} =$$ `{`token och $$\mathrm{T\_2} =$$ `\thetoken`. 3. `\expandafter` läser, och sparar sedan tillfälligt, den `{`token (TeX lagrar tillfälligt det heltals-tokenvärdet i en intern variabel). Senare kommer TeX att infoga tillbaka den tokenen i indata efter att ha bearbetat `\the` 4. `\expandafter` läser nästa token, `\the`token och expanderar det. 5. Expansionen av `\the` skapar en tillfällig tokenlista från bearbetningen av `\count99`—den tokenlistan innehåller en sekvens av teckentoken som representerar datavärdet som lagras i `\count` register `99`. 6. När `\the` har expanderats, infogar TeX tillbaka tokenen som sparades i steg 3 (`{`token) och lägger tillbaka den tokenen i indata. TeX gör detta genom att skapa en annan tokenlista som innehåller den *enda* token `{`token. 7. TeX har nu avslutat bearbetningen av `\expandafter` och har producerat två tokenlistor redo att användas som nästa indatakällor. TeX återgår till att bearbeta `\toks99=` men nu har TeX konfigurerat sin indata så att de två tokenlistor som skapats av `\expandafter` blir tokenkällan för `\toks`—som nu ser `{`token``tokenlista (tecken)`}`. `\toks` kan nu komma åt, och lagra, sekvensen av 5 teckentoken som representerar datavärdet (`12345`) lagrat i `\count99`: vårt önskade resultat. 8. Efter att ha läst alla teckentoken som producerats av `\the\count99`, återgår TeX till att hämta token från sin tidigare indatakälla (vår `.tex` fil) därifrån kommer den att läsa nästa token: den avslutande `}` som krävs för att avsluta listan av token som ska sparas av `\toks99={...}`. ## Hur \expandafter egentligen fungerar I det här avsnittet kommer vi att ta en “låg nivå”-titt inuti TeX själv: utforska källkoden/funktionerna i TeX som implementerar beteendet hos `\expandafter`. Detaljer uttrycks i pseudo-C-kod men bör vara tillgängliga för alla som är bekanta med andra programmeringsspråk. Följande kommenterade diagram förklarar hur TeX implementerar `\expandafter` som en del av en större funktion kallad `expand()`—kärnfunktionen som driver TeX:s expansionsbearbetning. Inom delen som ansvarar för att implementera `\expandafter` kan vi se [*rekursiva* beteendet](https://en.wikipedia.org/wiki/Recursion) där ytterligare ett anrop till `expand()` funktionen används för att bearbeta den andra token som läses in, $$\mathrm{T\_2}$$, för de fall där $$\mathrm{T\_2}$$ är expanderbart. Även om denna kod förekommer i Knuths TeX-motor, är de grundläggande principer som denna grafik beskriver tillämpliga på alla TeX-motorer. ![Hur \expandafter fungerar inuti TeX](/files/5bd3c71b5195aad61f28b3ed0b5fd272caee6302) Den första uppgiften för `expand()` är att avgöra om kommandot som ska expanderas är ett makro eller en primitiv eftersom makron har en specialiserad expansionsprocess som hanteras av en funktion kallad `macrocall()`. Om kommandot som ska expanderas är en primitiv, använder `expand()` funktionen det aktuella kommando-kodvärdet (lagrat i den globala variabeln `curcmd`) för att identifiera vilken specifik primitiv som behöver bearbetas. Vi kan se dessa detaljer i en mer fullständig listning av `expand()`: ``` void expand(void) { //curcmd är en global variabel if(curcmd != macro) // curcmd < 111 { switch(curcmd) { fall \expandafter: // Bearbeta kommandot \expandafter T1T2 { gettoken(); // Läs token T1 t = curtok; // Spara token T1 i den lokala variabeln t gettoken(); // Läs token T2 if(curcmd > 100) // Är token T2 expanderbar? expand(); // Ja! T2 är expanderbar: // utför expansion av T2 genom // att göra ett rekursivt funktionsanrop till expand() else backinput(); // T2 är inte expanderbar: lägg tillbaka den tokenen // tillbaka i indata för att läsas igen (senare) curtok = t ; // Återställ den globala variabeln curtok till det sparade värdet av T1 backinput() ; // Lägg tillbaka token T1 i indata // före de token som uppstår vid expansion av T2 } break; // Kod för att bearbeta andra expanderbara kommandon fall “konvertera till text”-kommandot: // Något av \number, \string, \romannumeral, // \meaning, \fontname, \jobname // De har samma värde på curcmd break; fall \noexpand: // Undertryck expansionen av nästa token ... break; fall \csname: // Skapa ett kontrollsekvensnamn. ... break; fall \the: // Infoga några token .... break; fall “\if... testkommandot” : // Bearbeta ett av TeX:s villkor: // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; fall “\fi eller \else”: // Avsluta det aktuella villkoret ... break; // osv. för alla andra expanderbara primitiva kommandon som stöds av // TeX-motorn } }else // Inte en expanderbar primitiv: det är ett makro { macrocall() } //... mer kod borttagen } ``` ### TeX:s kärlek till globala variabler Kanske som en spegling av dess ålder och den epok då det utformades använder TeX:s källkod i stor utsträckning så kallade [globala variabler](https://en.wikipedia.org/wiki/Global_variable)—faktiskt finns det hundratals av dem. Till sin natur kan globala variabler ändras/Modifieras var som helst i TeX:s källkod—vilket för Knuths TeX är en enda monolitisk fil som innehåller över 25 000 rader kod och hundratals funktioner. Att förstå hur TeX fungerar är inte alltid en lätt uppgift... För att bearbeta `\expandafter`, läser TeX token från sin aktuella indata med hjälp av en funktion som heter `gettoken()` vars uppgift är att skapa en token och ställa in värdet på flera viktiga globala variabler som används genom hela TeX:s källkod. Två sådana variabler, som uppdateras av funktionen `gettoken()`, används i implementeringen av `\expandafter`: * `curtok`: (aktuella tokenen) det heltalsvärde som tokenen som just lästes in har; * `curcmd`: (aktuella kommandokoden) kommandokoden för kommandot (eller tecknet) som tokenen representerar `curtok`. När man bearbetar `\expandafter`$$\mathrm{T\_1T\_2}$$ läser TeX tokenen $$\mathrm{T\_1}$$ och sparar tillfälligt dess värde (ett heltal) i en lokal variabel som heter `t`. TeX läser sedan $$\mathrm{T\_2}$$ och kontrollerar om tokenen representerar ett expanderbart kommando—genom att kontrollera om dess kommandokod (`curcmd`) är > 100. Om så är fallet måste TeX expandera kommandot som representeras av $$\mathrm{T\_2}$$ och gör ett nytt anrop till funktionen `expand()`: detta är ett exempel på *rekursion* eftersom `expand()` funktionen anropar sig själv. En förståelse för expansionens rekursiva natur, särskilt när man använder `\expandafter`, kan hjälpa till att förstå hur flera på varandra följande `\expandafter` kommandon—dvs., `\expandafter\expandafter\expandafter...` uppnår sina effekter. Om tokenen $$\mathrm{T\_2}$$ är expanderbar, sker expansionen och när det rekursiva anropet till `expand()` returnerar, kommer kod inom implementeringen av `\expandafter` att återinfoga tokenen $$\mathrm{T\_1}$$ tillbaka i indata. Den globala variabeln `curtok` tilldelas på nytt värdet av den sparade tokenen—lagrad i den lokala variabeln `t`, vilket är värdet av tokenen $$\mathrm{T\_1}$$—och ett anrop görs till funktionen `backinput().` #### Funktionen backinput() Som namnet antyder lägger den här funktionen en token “tillbaka i indata”. För att göra det använder TeX det aktuella värdet av den globala variabeln `curtok` för att skapa en tokenlista som innehåller en enda token (vars heltalsvärde ges av `curtok`). TeX ordnar också sin indatahantering så att den listan med en enda token vid lämplig tidpunkt läses in på nytt av TeX som en del av dess efterföljande indatahantering. Observera noga att tokenen $$\mathrm{T\_1}$$ återinfogas *efter att expansionen har slutförts*, vilket säkerställer att TeX läser den återinfogade tokenen *innan* när den läser token som uppstår vid expansion av $$\mathrm{T\_2}$$. ### Bearbeta makron: funktionen macrocall() Som tidigare diskuterats är alla makron, tillsammans med vissa primitiva kommandon, expanderbara och all expansionsbearbetning går genom `expand()` funktionen. Men `expand()` är noga med att använda `curcmd` (aktuellt kommando)-värdet för att skilja mellan expanderbara primitiv och makron eftersom makroexpansionsprocessen hanteras av en särskild funktion som heter `macrocall()`. Makron behöver en specialiserad expansionsprocess eftersom makroargument och avgränsningstoken måste sökas igenom på ett mycket särskilt och rigoröst sätt; därför delegeras den processen till en funktion som är utformad för att göra det: `macrocall()`. #### Makroexpansion kontra makrokörning Makro *expansion* är inte samma process som makro *körning*: expansion av ett makro är den förkörningsprocess som TeX utför för att göra makrot *redo för körning*. Ett makros “körning” sker när TeX aktivt läser och bearbetar token som finns i makrots definition (ersättningstext) och dess argument (parametrar). #### Makroexpansion För att expandera ett makro kontrollerar TeX först om makrot tar argument; i så fall, `macrocall()` skannar mycket noggrant indata efter token som är avsedda att bli makrots argument. Den processen omfattar att kontrollera användarens indata efter eventuella avgränsningstoken som används i makrots ursprungliga definition—mönstret av token som används i ett makroanrop måste exakt matcha mönstret av token som finns i den lagrade definitionen. Token som används som avgränsare kastas dock helt enkelt bort av TeX: de är i praktiken bara en form av “interpunktion” som TeX använder för att avgöra vilka faktiska token som är avsedda att bli makrots argument—dvs. token som användaren avser att makrot ska bearbeta. För mer information om avgränsningstoken, se [Hur TeX-makron faktiskt fungerar](/latex/sv/fler-amnen/22-how-tex-macros-actually-work-part-4.md). För varje parameter (`#1, #2...#9`) som finns i makrots ursprungliga definition skannar TeX det faktiska makroanropet för att identifiera vilka token som tillhandahållits av användaren som är avsedda för varje parameter (dvs. utgör makrots argument). Den processen producerar en eller flera små tokenlistor: en för varje makroargument. När eventuella makroargument har upptäckts och deras tokenlistor har förberetts hämtar TeX makrots definition (ersättningstext) som lagras i dess minne och ordnar sin indatahantering så att närhelst TeX är redo att läsa/bearbeta fler token kommer den att läsa dem från makrots ersättningstext och därmed köra makrot. Vid den lämpliga tidpunkten, under makrokörningen, kommer tokenlistor som representerar makroargumenten att matas in på rätt plats i makrots ersättningstext. Återigen betyder expansion av ett makrokommando *att ta bort* det makrokommandot (tokenen) från indata och *att ersätta* det med tokenlistan som lagrats som makrots ersättningstext. För en fördjupad titt på TeX:s makrobearbetning, se artikelserien i sex delar [Hur fungerar TeX-makron egentligen?](/latex/sv/fler-amnen/01-a-six-part-series-how-do-tex-macros-actually-work.md) [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/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.