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

# Hvordan TeX-makroer egentlig fungerer: Del 6

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

## Innledning og oversikt: Historien så langt

I de foregående 5 delene av denne serien har vi sett:

* hvordan TeX leser tegnene i en inputfil og bruker kategorikoder til å gjenkjenne ulike «klasser» av tegn og deretter konvertere dem til tegn-tokener og kommando-tokener;
* at en makro i praksis består av fire deler:

```
<TeX-makro-primitive><makronavn><parametertekst>{<erstatningstekst>}
```

der:

* `<TeX-makro-primitive>` = en av `\def`, `\edef`, `\gdef` eller `\xdef`;
* `<makronavn>`= navnet på makroen din, for eksempel `\foo`;
* `<parametertekst>` kan være «null» (ikke til stede), eller det kan være en streng av skilletegn-tokener og makroparameter-tokener;
* `<erstatningstekst>` er den faktiske kroppen til makroen din: delen som blir «utført» (ekspandert) når du kaller makroen.
* hvordan `<parametertekst>` delen kan inneholde et bredt spekter av tokener, og at TeX bruker denne delen som en «tokentmal» for å matche et makrokall med den opprinnelige definisjonen og finne ut argumentene som brukes sammen med makroen — og hvordan TeX forventer at bruken din av en makro skal samsvare med den opprinnelige definisjonen;
* at en makrodefinisjon inne i TeX lagres som en sammenhengende sekvens av tokener som representerer `<parametertekst>` og `<erstatningstekst>` delene.

Når du bruker en makrokommando vil TeX først sjekke om den tar noen parametere. Hvis så er tilfelle, må TeX deretter identifisere de faktiske *argumentene* som brukes i makrokallet ditt. TeX må teste makrokallet ditt mot definisjonen av «tokentmalen» den har lagret i minnet. Mer spesifikt bruker TeX den interne (lagrede) definisjonen av makroens `<parametertekst>` delen som mal slik at den kan plukke ut *tokens* som er de faktiske argumentene, og hvilke *tokens* som bare er der for å fungere som skilletegn.

## Betydningen av makroekspansjon

Vi er nå endelig klare til å gå videre til det viktigste emnet: hvordan TeX behandler makroargumenter og faktisk utfører makroen: en prosess TeX omtaler som *makroekspansjon*.

### Men først, et kort eksempel: noe merkelig?

For å «sette scenen» for å forklare mekanismen som TeX behandler makroer og argumentene deres med, skal vi bruke et kort eksempel for å vise hvilke spørsmål vi må ta hensyn til.

#### Argumenter konverteres først til tokener

Følgende eksempel er basert på ett som diskuteres på side 114–5 i [The Advanced TeXbook](https://www.amazon.co.uk/Advanced-Texbook-David-Salomon/dp/0387945563) skrevet av David Salomon. Det er valgt fordi det på en fin måte oppsummerer kjernetankene i en svært kort TeX-makro.

Under vanlig TeX/LaTeX-drift, har `$` tegnet kategorikode 3 («math shift»), som slår TeX inn/ut av inline matematikkmodus (`$...$`) eller display-mattemodus (`$$...$$`) — selvfølgelig bruker LaTeX `\(..\)` og `\[..\]` til samme formål.

Anta at vi ønsker en makro som endrer kategorikoden til et `$` dollartegn til for eksempel 11, slik at vi kan sette det som et vanlig tegn. Vi kan bruke TeXs primitive kommando `\catcode` og vårt første forsøk på en slik makro, `\docat`, kan være

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

Men når vi prøver å bruke den, slik:

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Jeg betalte \docat{$90} for den boken.
\end{document}
```

forventer vi at TeX skal sette `Jeg betalte $90 for den boken.` men det mislykkes med en feilmelding:

```
! Manglende $ satt inn.
<innsatt tekst>
                $
<to be read again>
                   \par
l.7
```

Av feilmeldingen ser det ut til at `$` brukt i argumentet til makroen vår fortsatt utløser at TeX setter matematikk; tydeligvis *gjorde ikke* endre kategorikoden til `$` brukt i argumentet til makroen vår (`$90`). Spørsmålet er *hvorfor* hvorfor endret ikke TeX kategorikoden til `$` til 11 og satte det som et vanlig tegn? Det korte svaret er at TeX først konverterer makroargumenter til tokener **før** før den mater dem inn i tokensekvensen til `<erstatningstekst>`—men vi skal se på de underliggende mekanismene i mye større detalj.

Det vi må huske er at vår oppfatning av TeX som bruker tekst/tegn bare er relevant for innholdet i filen som TeX leser: så snart TeX har lest inn noen tegn, er vi i verdenen av *tokens*. TeX-makrokall arbeider med *tokens*, ikke den faktiske *skriftlige/tekstlige representasjonen* av TeX/LaTeX-kommandoer — dette vil bli klarere etter hvert som vi går gjennom eksemplet.

I utgangspunktet kan vi kanskje tro at bruken vår av `\docat` -makroen i `Jeg betalte \docat{$90} for den boken.` er det samme som å skrive den tilsvarende TeX- (eller LaTeX-)koden direkte — for eksempel følgende, som *ikke* fungerer:

```
\begin{document}
Jeg betalte \catcode`\$=11 $90 for den boken.
\end{document}
```

![Noe TeX-kode som kjører på Overleaf](/files/51f7d3efaccccdf54ce18d222b819c9d29d2a98c)

Men som vi så ovenfor, gir måten TeX behandler makroargumenter på et resultat (`! Manglende $ satt inn.`) som er ganske forskjellig fra å skrive ut TeX-koden: nå skal vi utforske *hvorfor* som skjer.

### Makroer og argumenter som tokensekvenser

For å fullt ut forstå oppførselen til `\docat` -makroen, og argumentet dens (`$90`), og hvorfor den mislykkes, må vi igjen visualisere definisjonen til `\docat` -makroen og eventuelle argumenter som brukes (når \docat kalles) som *som tokenlister*, ikke som en sekvens av tegn.

Når TeX skanner inndata-teksten din, vil den gjenkjenne `\docat` som en makrokommando; etter det sjekker den om den tar noen parametere — hvordan TeX gjør det, forklares i neste avsnitt for lesere som er interessert i de finere detaljene.

#### For dem som liker detaljene...

Etter at makroen er kalt, sjekker TeX om det aller første tokenet (i makroens lagrede definisjonstokensekvens) er **sluttmatch** -tokenet: hvis ja, kan TeX være sikker på at makroen ikke tar noen parametere.

**Et eksempel**

Følgende node-liste-diagrammer sammenligner tokenlistene for to makroer:

* `\def\foo A#1B{#1}`: denne har `<parametertekst>` på `A#1B`, derfor er **sluttmatch** tokenet **inneholder** det første tokenet, så TeX vil fortsette med å se etter parametere;
* `\def\foo{X}`: denne har ikke en `<parametertekst>` del, derfor er **sluttmatch** tokenet det første i tokensekvensen, og TeX vet at den ikke skal se etter noen parametere.

![Hvordan TeX sjekker om en makro tar parametere](/files/2f9ca28c93073257f1ade19f1026629ea94cfaf7)

## Mot «den store finalen»: ekspansjon

La oss minne oss selv om spørsmålet: hvorfor virket ikke den følgende makroen; altså, hvorfor endrer ikke TeX kategorikoden til noen `$` dollartegn brukt i argumentet til `\docat` makroen, slik som `\docat{$90}`?

```
\begin{document}
\def\docat #1{\catcode`\$=11 #1}
Jeg betalte \docat{$90} for den boken.
\end{document}
```

Som forklart ovenfor, når TeX skanner inndataene dine og gjenkjenner en makrokommando — på et tidspunkt når TeX skal utføre den — sjekker TeX først om den makroen tar noen parametere. Hvis så er tilfelle, må TeX deretter skanne inputfilen videre for å identifisere de faktiske *argumentene* som brukeren har oppgitt for dette spesifikke makrokallet: TeX må gjøre dette **før** før den kan kalle den faktiske makrokoden. Tydeligvis må TeX bestemme dataene som brukeren vil gi makroen.

For å identifisere argumentene som finnes i inndataene (brukerens makrokall), vil TeX bli ledet av den internt lagrede definisjonen av den makroen: nærmere bestemt `<parametertekst>` delen av den lagrede makrodefinisjonen (tokensekvensen) — den gir en slags «tokentmal». Ved hjelp av denne «tokentmalen» må TeX avgjøre hvilke *tokens* i brukerens makrokall som bare er *avgrensere* (i praksis «tegnsetting») og hvilke *tokens* utgjør en del av et *argument*. Det er når TeX møter et **match-parameter** -token i den lagrede makrodefinisjonen `<parametertekst>` -delen («tokentmalen») at den vet at den skal begynne å danne en *tokenliste* for det aktuelle argumentet.

Så snart TeX gjenkjenner behovet for å identifisere brukerens argument, vil TeX skanne inputen for å generere tokener og kontrollere dem svært nøye, token for token, mot den lagrede makrodefinisjonen. TeX fortsetter å samle tokener for et argument til den oppdager et token som faktisk er et skilletegn, eller hvis den oppdager **sluttmatch** -tokenet: i begge tilfeller vet TeX da at det er på tide å slutte å se etter tokener som er en del av det argumentet.

### Hvorfor \docat-makroen mislyktes

Som nevnt, *før* For at TeX faktisk skal kunne kalle en makro, må den identifisere og forberede eventuelle argumenter som skal brukes sammen med den makroen. Men for å identifisere argumentet/argumentene, klare til å mates inn i makroen, må TeX generere hvert argument som en *tokenliste*: og det er grunnen til `\docat`-mislykket.

I vårt eksempel ga vi `\docat` med et argument på `$90` men det argumentet blir først *konvertert til en tokensekvens* idet TeX skanner makrokallet — argumentet konverteres til tokener *før* før makroen faktisk kalles. Her, for argumentet `$90`, vil TeX generere tre tegntokener: ett token for hver av `$`, `9` og `0`.

Følgende grafikk viser tokensekvensen som genereres for argumentet `$90`, før det mates inn i kroppen til `\docat` makroen:

![TeX-tokensekvens generert for et makroargument](/files/34ff9ba2181ff71e7dade40f4c29e4b679f52a33)

I grafikken ovenfor kan vi tydelig se at argumenttokensekvensen inneholder `$` som et tegntoken basert på en kategorikode på 3.

Som vi så i Del 1 til 3, opprettes tegntokener ved hjelp av kategorikodeverdiene *som er i bruk på det tidspunktet tegnet leses inn*—dvs. på det tidspunktet argumentets tokensekvens opprettes (gjøres om til tokener). På tidspunktet argumentene blir tokenisert, har `\docat` -makroen ennå ikke blitt utført, så kategorikodeendringen vi la inn i makrokallet (``\catcode`\$=11``) *ikke* påvirker ikke kategorikodene som brukes til å generere argumentets tokener.

Når TeX først har generert en tokensekvens som representerer argumentet til `$90`, mates disse tre tegntokenene inn i den faktiske makro `<erstatningstekst>`. Men det resulterer i at `$` blir matet inn som en *tegn-token* opprettet ved hjelp av kategorikode 3: «math on», og vi har sett at når et tegntoken først er dannet, er den tilknyttede kategorikoden permanent. De `$` er *inneholder* som mates inn i makroen *som et tegn*, men som et *tegn-token* basert på `$` at den har kategorikode 3.

### Å kjøre \docat: makroekspansjon

TeX omtaler prosessen med å «utføre» en makro som *makroekspansjon*; et begrep som, etter denne forfatterens mening, er litt forvirrende, men det er den aksepterte terminologien, så vi fortsetter å bruke det.

#### Den egentlige betydningen av makroekspansjon

Etter at TeX oppdager `\docat` -kommandoen i brukerens inndata, skanner den argumentene og genererer en tokensekvens for argumentet sitt (`$90`). For å utføre (ekspandere) makroen, vender TeX blikket bort fra brukerens inputfil og begynner å lese tokene som finnes `\docat`s `<erstatningstekst>` tokensekvensen som er lagret i TeXs minne.

Når TeX behandler `\docat`sin definisjon, vil den deretter se og utføre serien av tokener som opprinnelig ble brukt til å definere makroen (`**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**#1**`).

Følgende grafikk viser prosessen med å ekpandere `\docat` -makroen: TeX slutter å hente tokener fra inputfilen og begynner å lese tokener fra `<erstatningstekst>` -delen av `\docat` -makrodefinisjonen som er lagret i minnet. TeX fortsetter å utføre disse forhåndsklare tokene til den ser et **utparameter** token som instruerer TeX til å lese («injisere») og «utføre» argumenttokene på dette punktet. I vårt eksempel er det tre tegntokener som representerer `$90` og som resulterer i en feil fordi det forhåndsklare tegntokenet for `$` er upåvirket av den tidligere kategorikodeendringen forårsaket av tokenene i `$` Showing the process of expanding the modified \docat macro and the \getarg macro ``\catcode`\$=11``.

![Viser prosessen med å ekpandere \docat-makroen](/files/fda649fa28435e53efbf31bc86241fada4f20939)

Etter at TeX har behandlet tokene som representerer ``\catcode`\$=11``, vil kategorikodeendringen for `$` nå være i kraft. TeX møter deretter det «spesielle tokenet» kalt **utparameter** som forteller TeX å **setter TeX-motorer inn** tokensekvensen for argumentet. Men den tokensekvensen er tre tegn *tokens*, hvor den første er et token for en `$` med en kategorikode 3 («math on») tildelt den: den tidligere kategorikodeendringen inne i makroen kan ikke påvirke dette tegntokenet, så TeX behandler det tokenet som et signal om å begynne matematikkbehandling, noe som får makroen til å mislykkes.

### Kan \docat-makroen fikses?

Ut fra diskusjonene ovenfor er det klart at alle tegn som opptrer i makroargumenter, tokeniseres ved hjelp av kategorikodene som er i kraft på det tidspunktet tokeniseringen finner sted — som i vårt eksempel er *alltid* før `<erstatningstekst>` i `\docat` makroen faktisk blir utført. Så hvordan kan vi sikre at en makros argumenter får endret kategorikodene sine?

En måte er å endre `\docat` til å være en parameterløs makro som bare gjør kategorikodeendringen — den har ingen argumenter å tokenisere. Deretter bruker vi en annen makro, `\getarg`, som tar ett enkelt parameter, og sørger for at argumentet til den makroen blir tokenisert når den passende kategorikoden for `$` er i bruk.

```
\begin{document}
\def\docat{\catcode`\$=11 \getarg} % Ingen parametere, kaller en annen makro \getarg
\def\getarg#1{#1} %1 parameter hvis argument vil bli tokenisert
Nå kan du kjøre den slik, og det vil virke:

Jeg betalte \docat{$90} for den boken.
\end{document}
```

Når vi bruker den nye versjonen av `\docat` (slik: `\docat{$90}`) *ser den* ut `$90` som om `\docat` fortsatt `\docat` brukes som et argument for `\docat` -makroen. Men som diskutert ovenfor, når TeX oppdager `**catcode**`, ``**`**``, `**\$**`, `**=**`, `**1**`, `**1**`, `**mellomrom**`, `**getarg**` og dette skjer *før* idet TeX begynner å lese (tokenisere) de neste tegnene som finnes i inputfilen — dvs. gruppen `{$90}`. Husk at når TeX ekspanderer en makro, får den neste input ved å lese tokene som finnes i tokensekvensen til makroens definisjon; dvs. fra dens `<erstatningstekst>` -del lagret i minnet.

TeX vil behandle, og utføre, ekspansjonen av `\docat` og oppdage *tokenet* **`getarg`**, og gjenkjenne det som et token som representerer en kommando som tar parametere. På dette punktet vil TeX skanne inputfilen for **`getarg`**-argumentet: tegnene: `{$90}`. Som vanlig blir disse tokenisert, men fordi TeX har lest og behandlet ekspansjonen av `\docat`, blir tegnene `$90` tokenisert når kategorikoden til `$` har blitt endret til 11. Definisjonen (`<erstatningstekst>`) av `\getarg` er ganske enkelt `#1` som betyr å sette opp det oppgitte argumentet, og det er det som skjer, noe som resulterer i en `$` med kategorikode 11 som blir generert og trygt satt.

## Avsluttende bemerkninger: historien i noder

Sekvensen av hendelser som oppstår når vi omskriver `\docat` for å bruke makroen `\getarg` finnes i følgende kommenterte node-liste-diagram, som viser ekspansjonsprosessen for makroen `\docat`. Lesere som ønsker å studere dette diagrammet nøye, kan laste ned grafikken 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 for bruk offline.

![Viser prosessen med å ekpandere den modifiserte \docat-makroen og \getarg-makroen](/files/00749f5b9612a1339b4d8e1944f42d9946ad44ca)

[Del 1](/latex/no/flere-emner/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/no/flere-emner/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/no/flere-emner/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/no/flere-emner/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/no/flere-emner/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/no/flere-emner/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/no/flere-emner/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.