> 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/fler-amnen/24-how-tex-macros-actually-work-part-6.md).

# Hur TeX-makron egentligen fungerar: Del 6

[Del 1](/latex/sv/fler-amnen/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/sv/fler-amnen/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/sv/fler-amnen/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/sv/fler-amnen/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/sv/fler-amnen/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/sv/fler-amnen/24-how-tex-macros-actually-work-part-6.md)

## Introduktion och översikt: Historien hittills

Under de föregående 5 delarna i denna serie har vi sett:

* hur TeX läser tecknen i en indatafil och använder kategorikoder för att känna igen olika ”klasser” av tecken och därefter omvandla dem till teckentoken och kommandotoken;
* att ett makro i praktiken består av fyra delar:

```
<TeX macro primitive><macro name><parameter text>{<replacement text>}
```

där:

* `<TeX macro primitive>` = en av `\def`, `\edef`, `\gdef` eller `\xdef`;
* `<makronamn>`=namnet på ditt makro, till exempel `\foo`;
* `<parametertext>` kan vara ”null” (inte närvarande) eller så kan det vara en sträng av avgränsningstoken och makroparametertoken;
* `<ersättningstext>` är den faktiska kroppen i ditt makro: den del som ”körs” (expanderas) när du anropar makrot.
* hur `<parametertext>` sektionen kan innehålla ett brett spektrum av token och att TeX använder denna sektion som en ”tokentemplate” för att matcha ett makroanrop mot dess ursprungliga definition och räkna ut de argument som används med makrot—och hur TeX förväntar sig att din användning av ett makro ska matcha dess ursprungliga definition;
* att en makrodefinition i TeX lagras som en kontinuerlig följd av token som representerar `<parametertext>` och `<ersättningstext>` delarna.

När du använder ett makrokommando kommer TeX först att kontrollera om det tar några parametrar. Om så är fallet måste TeX sedan identifiera de faktiska *argument* som används i ditt makroanrop. TeX måste testa ditt makroanrop mot den ”tokentemplat”-definition som det har lagrat i minnet. Mer specifikt använder TeX den interna (lagrade) definitionen av din makros `<parametertext>` sektion som mall genom vilken det kan plocka ut *tokens* som är de faktiska argumenten, och vilka *tokens* bara finns där för att fungera som avgränsare.

## Betydelsen av makroexpansion

Vi är nu äntligen redo att gå vidare till det viktigaste ämnet: hur TeX bearbetar makroargument och faktiskt kör makrot: en process som TeX kallar *makroexpansion*.

### Men först, ett kort exempel: något märkligt?

För att ”sätta scenen” för att förklara mekanismen genom vilken TeX bearbetar makron och deras argument, använder vi ett kort exempel för att visa de frågor vi behöver beakta.

#### Argument konverteras först till token

Följande exempel bygger på ett som diskuteras på sidorna 114–5 i [The Advanced TeXbook](https://www.amazon.co.uk/Advanced-Texbook-David-Salomon/dp/0387945563) skriven av David Salomon. Det har valts eftersom det på ett bra sätt sammanfattar de centrala idéerna i ett mycket kort TeX-makro.

Under normal TeX/LaTeX-användning har `$` tecknet kategorikod 3 (”math shift”) vilket växlar TeX in/ur inbyggt matematikläge (`$...$`) eller visningsmatematikläge (`$$...$$`) — naturligtvis använder LaTeX `\(..\)` och `\[..\]` för samma syften.

Anta att vi vill ha ett makro som ändrar kategorikoden för ett `$` tecken till exempelvis 11 så att vi kan sätta det som vilket vanligt tecken som helst. Vi kan använda TeX:s primitiva kommando `\\catcode` och vårt första försök till ett sådant makro, `\docat`, kan vara

```
\def\docat #1{\catcode`\$=11 #1}
```

Men när vi försöker använda det så här

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Jag betalade \docat{$90} för den boken.
\end{document}
```

förväntar vi oss att TeX sätter texten `Jag betalade $90 för den boken.` men det misslyckas med ett felmeddelande:

```
! Saknat $ infogat.
<infogat text>
                $
<to be read again>
                   \par
l.7
```

Av felet verkar det som att `$` som används i argumentet till vårt makro fortfarande får TeX att sätta matematik; tydligtvis har TeX *inte* ändrat kategorikoden för `$` som används i vårt makroargument (`$90`). Frågan är *varför* varför ändrade inte TeX kategorikoden för `$` till 11 och satte det som ett vanligt tecken? Det korta svaret är att TeX först konverterar makroargument till token **innan** innan den matar in dem i tokenlistan för `<ersättningstext>`— men vi ska titta på de underliggande mekanismerna mycket mer i detalj.

Det vi behöver komma ihåg är att vår föreställning om att TeX använder text/tecken bara är relevant för innehållet i filen som TeX läser: så snart TeX har läst in några tecken befinner vi oss i världen av *tokens*. TeX-makroanrop arbetar med *tokens*, inte den faktiska *skrivna/textuella representationen* av TeX/LaTeX-kommandon — detta blir tydligare när vi går igenom exemplet.

Inledningsvis kanske vi tror att vår användning av `\docat` makrot i `Jag betalade \docat{$90} för den boken.` är samma sak som att direkt skriva motsvarande TeX- (eller LaTeX-)kod — till exempel följande, som *gör* fungerar:

```
\begin{document}
Jag betalade \catcode`\$=11 $90 för den boken.
\end{document}
```

![Någon TeX-kod som körs på Overleaf](/files/284a0fba610e0d886d0ad6eb91fb0bd0755d9d79)

Men som vi såg ovan ger det sätt som TeX bearbetar makroargument på ett resultat (`! Saknat $ infogat.`) som är ganska annorlunda jämfört med att skriva ut TeX-koden: vi ska nu utforska *varför* vad som händer.

### Makron och argument som tokenlistor

För att fullt ut förstå beteendet hos `\docat` makrot och dess argument (`$90`), och varför det misslyckas, behöver vi återigen visualisera definitionen av `\docat` makrot och alla argument som används (när \docat anropas) som *listor av token*, inte som en följd av tecken.

När TeX skannar din inmatade text känner den igen `\docat` som ett makrokommando; därefter kontrollerar den om det tar några parametrar — hur TeX gör detta förklaras i följande avsnitt för läsare som är intresserade av de finare detaljerna.

#### För den som gillar detaljerna...

När makrot har anropats kontrollerar TeX om den allra första token (i makrots lagrade definitions-tokenlista) är **slutmatchnings** token: i så fall kan TeX vara säker på att makrot inte tar några parametrar.

**Ett exempel**

Följande nodlistdiagram jämför tokenlistorna för två makron:

* `\def\foo A#1B{#1}`: detta har `<parametertext>` för `A#1B`, följaktligen är **slutmatchnings** tokenen **inte** den första tokenen, så TeX skulle fortsätta att leta efter parametrar;
* `\def\foo{X}`: detta har ingen `<parametertext>` sektion, följaktligen är **slutmatchnings** tokenen den första i tokenlistan och TeX vet att den inte ska leta efter några parametrar.

![Hur TeX kontrollerar om ett makro tar parametrar](/files/8e0221ce69c2f687e442f1c3c024518e372320c2)

## Mot ”grand finalen”: expansion

Låt oss påminna oss om frågan: varför fungerade inte följande makro; dvs. varför ändrar inte TeX kategorikoden för några `$` tecken som används i argumentet till `\docat` makrot, såsom `\docat{$90}`?

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Jag betalade \docat{$90} för den boken.
\end{document}
```

Som förklarats ovan, när TeX skannar din inmatning och känner igen ett makrokommando — vid en tidpunkt då TeX ska köra det — kontrollerar TeX först om makrot tar några parametrar. Om så är fallet måste TeX skanna indatafilen vidare för att identifiera de faktiska *argument* som användaren har tillhandahållit för just detta makroanrop: TeX måste göra detta **innan** innan den kan anropa den faktiska makrokoden. Självklart behöver TeX avgöra vilka data användaren vill ge makrot.

För att identifiera de argument som finns i indata (användarens makroanrop) styrs TeX av den internt lagrade definitionen av det makrot: närmare bestämt `<parametertext>` sektionen i den lagrade makrodefinitionen (tokenlistan) — som fungerar som en sorts ”tokentemplate”. Med hjälp av den ”tokentemplaten” måste TeX avgöra vilka *tokens* i användarens makroanrop som bara är *avgränsare* (i huvudsak ”interpunktion”) och vilka *tokens* utgör en del av ett *argument*. Det är när TeX stöter på en **matchparameter-** token i den lagrade makrodefinitionens `<parametertext>` sektion (”tokentemplate”) som den vet att den ska börja forma en *tokenlista* för just det argumentet.

Så snart TeX inser behovet av att identifiera användarens argument skannar TeX inmatningen för att generera token och kontrollerar dem mycket noggrant, token för token, mot den lagrade makrodefinitionen. TeX fortsätter att samla token för ett argument tills den upptäcker en token som faktiskt är en avgränsare, eller om den upptäcker **slutmatchnings** tokenen: i båda fallen vet TeX då att det är dags att sluta leta efter token som utgör en del av det argumentet.

### Varför \docat-makrot misslyckades

Som nämnts, *innan* TeX kan faktiskt anropa ett makro måste det identifiera och förbereda de argument som ska användas med det makrot. Men för att identifiera argumenten, redo att matas in i makrot, måste TeX generera varje argument som en *tokenlista*: och det är orsaken till `\docat`s misslyckande.

I vårt exempel gav vi `\docat` ett argument till `$90` men det argumentet blir först *konverterat till en lista av token* när TeX skannar makroanropet — argumentet konverteras till token *innan* innan makrot faktiskt anropas. Här, för argumentet `$90`, kommer TeX att generera tre teckentoken: en token för var och en av `$`, `9` och `0`.

Följande graf visar tokenlistan som genereras för argumentet `$90`, innan den matas in i kroppen av `\docat` makrot:

![TeX-tokenlista genererad för ett makroargument](/files/79c16cc1de3e2e7c2ad01d77a69ed316caaf5213)

I grafiken ovan kan vi tydligt se att argumentets tokenlista innehåller `$` som en teckentoken baserad på en kategorikod på 3.

Som vi såg i del 1 till 3 skapas teckentoken med hjälp av kategorikodsvärden *som gäller vid den tidpunkt då tecknet läses in*— dvs. när argumentets tokenlista skapas (omvandlas till token). När argumenten tokeniseras har `\docat` makrot ännu inte körts så kategorikodsförändringen vi satte i makroanropet (``\catcode`\$=11``) *gör inte* påverkar inte de kategorikoder som används för att generera argumentets token.

När TeX har genererat en tokenlista som representerar argumentet till `$90`, matas dessa tre teckentoken in i själva makrot `<ersättningstext>`. Men det leder till att `$` matas in som en *teckentoken* skapad med kategorikod 3: ”math on”, och vi har sett att när en teckentoken väl har bildats är den tillhörande kategorikoden permanent. Den `$` är *inte* som matas in i makrot *som ett tecken*, men som en *teckentoken* baserad på `$` att ha kategorikod 3.

### Att köra \docat: makroexpansion

TeX kallar processen att ”köra” ett makro för *makroexpansion*; en term som, enligt denna författare, är lite förvirrande men det är den vedertagna terminologin så vi fortsätter att använda den.

#### Den verkliga betydelsen av makroexpansion

Efter att TeX har upptäckt `\docat` kommandot i användarens indata, skannar det argumenten och genererar en tokenlista för dess argument(`$90`). För att köra (expandera) makrot flyttar TeX blicken bort från användarens indatafil och börjar läsa token som finns i `\docat`’s `<ersättningstext>` tokenlistan lagrad i TeX:s minne.

När TeX bearbetar `\docat`s definition kommer det sedan att se och köra den serie token som ursprungligen användes för att definiera makrot (`**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**#1**`).

Följande graf visar processen att expandera `\docat` makrot: TeX slutar hämta token från indatafilen och börjar läsa token från `<ersättningstext>` sektionen i `\docat` makrodefinitionen lagrad i minnet. TeX fortsätter att köra dessa förberedda token tills den ser en **utparameter-** token som instruerar TeX att läsa in (”injicera”) och ”köra” argumenttokenen här. I vårt exempel är det tre teckentoken som representerar `$90` och det leder till ett fel eftersom den förberedda teckentoken för `$` har kategorikod 3. Eftersom vi arbetar med teckentoken, inte tecken, påverkas `$` inte av den tidigare kategorikodsförändringen orsakad av token i ``\catcode`\$=11``.

![Visar processen för att expandera \docat-makrot](/files/5613987d011b255b2b95eb93f62ec51a4b83a9ff)

Efter att TeX har bearbetat token som representerar ``\catcode`\$=11``, kommer kategorikodsförändringen för `$` att gälla. TeX stöter sedan på den ”specialtoken” som heter **utparameter-** som säger åt TeX att **infogar** tokenlistan för argumentet. Men den tokenlistan består av tre tecken *tokens*, varav den första är en token för en `$` med kategorikod 3 (”math on”) tilldelad: den tidigare kategorikodsförändringen inom makrot kan inte påverka denna teckentoken så TeX behandlar den tokenen som en signal att börja matematikbearbetning vilket gör att makrot misslyckas.

### Kan \docat-makrot fixas?

Av diskussionen ovan framgår tydligt att alla tecken som förekommer i makroargument tokeniseras med de kategorikoder som gäller vid den tidpunkt tokeniseringen sker — vilket i vårt exempel är *alltid* före att `<ersättningstext>` av `\docat` makrot faktiskt körs. Så hur kan vi säkerställa att ett makros argument får sina kategorikoder ändrade?

Ett sätt är att ändra `\docat` så att det blir ett parameterlöst makro som bara gör kategorikodsförändringen — det har inga argument att tokenisera. Sedan använder vi ett andra makro, `\getarg`, som tar en enda parameter, och ser till att det makrot får sitt argument tokeniserat när rätt kategorikod för `$` är i bruk.

```
\begin{document}
\def\docat{\catcode`\$=11 \getarg} % Inga parametrar, anropar ett andra makro \getarg
\def\getarg#1{#1} %1 parameter vars argument kommer att tokeniseras
Nu kan du köra det så här och det fungerar:

Jag betalade \docat{$90} för den boken.
\end{document}
```

När vi använder vår nya version av `\docat` (så här `\docat{$90}`) verkar det *som att* fortfarande används som ett argument till `$90` makrot. Men som diskuterats ovan, när TeX upptäcker `\docat` i indata kontrollerar den om det har några argument: nu gör det inte det, så TeX fortsätter att köra (expandera) det. Expansionen av `\docat` är följden av token `\docat` \*\*mellanslag\*\* `**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**getarg**`, `och detta sker` TeX börjar läsa (tokenisera) de nästa tecken som finns i indatafilen — dvs. gruppen *innan* . Kom ihåg att när TeX expanderar ett makro får det sin nästa indata genom att läsa token som finns i tokenlistan i det makrots definition; dvs. från dess `{$90}`sektion lagrad i minnet. `<ersättningstext>` TeX kommer att bearbeta och köra expansionen av

och upptäcka `\docat` tokenen *token* **`getarg`**, och känna igen den som en token som representerar ett kommando som tar parametrar. Vid denna punkt skannar TeX indatafilen efter **`getarg`**&#x73; argument: tecknen: `{$90}`. Som vanligt tokeniseras dessa, men eftersom TeX har läst och bearbetat expansionen av `\docat`, tokeniseras tecknen `$90` när kategorikoden för `$` har ändrats till 11. Definitionen (`<ersättningstext>`) av `\getarg` är helt enkelt `#1` vilket betyder sätt den givna argumentet, och det är vad som händer, vilket resulterar i en `$` med kategorikod 11 som genereras och sätts utan problem.

## Avslutande anmärkningar: historien i noder

Följden av händelser som uppstår när man skriver om `\docat` för att använda makrot `\getarg` finns i följande kommenterade nodlistdiagram som visar expansionsprocessen för makrot `\docat`. Läsare som vill studera detta diagram noggrant kan ladda ner grafiken som en [PDF](https://assets.ctfassets.net/nrgyaltdicpt/7MOBdavza4WxAEQGISEEht/cabe5097d9063a6415bc553cd38237e6/newdocatexpansion.pdf) eller [SVG](https://images.ctfassets.net/nrgyaltdicpt/2FIqqVRXjakdAzTpZsV0m9/10ccc1353741d42d3df18f1692d8aa84/newdocatexpansion--plain.svg) fil för användning offline.

![Visar processen för att expandera det modifierade \docat-makrot och \getarg-makrot](/files/c0cc1d06d82b63eafca3b46ec5149083ccb4876c)

[Del 1](/latex/sv/fler-amnen/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/sv/fler-amnen/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/sv/fler-amnen/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/sv/fler-amnen/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/sv/fler-amnen/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/sv/fler-amnen/24-how-tex-macros-actually-work-part-6.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/fler-amnen/24-how-tex-macros-actually-work-part-6.md?ask=<question>&goal=<endgoal>
```

`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.