> 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/da/flere-emner/22-how-tex-macros-actually-work-part-4.md). # Sådan virker TeX-makroer egentlig: Del 4 [Del 1](/latex/da/flere-emner/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/da/flere-emner/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/da/flere-emner/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/da/flere-emner/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/da/flere-emner/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/da/flere-emner/24-how-tex-macros-actually-work-part-6.md) ## Introduktion og oversigt I delene 1–3 dykkede vi ned i nogle lavniveau-baggrundsdetaljer som forberedelse til at forstå, hvordan TeX-makroer virker. I denne artikel skal vi lige ”komme op til overfladen” og gennemgå nogle grundlæggende praktiske principper for TeX-makroer som forberedelse til endnu et dyk i delene 5 og 6. Gennem hele denne artikel vil vi vise eksempelmakroer defineret ved hjælp af TeXs primitive kommando `\def`: vi vil ikke bruge den måske mere kendte LaTeX-kommando `\newcommand`. Der er en meget god grund til det: vores mål er at forstå de grundlæggende principper bag TeXs makroadfærd, men for at gøre det må vi bruge kernekommandoer *indbygget i* TeX-softwaren. LaTeX-kommandoer, såsom `\newcommand`, er i sig selv makroer: kommandoer med en bestemt programmeret adfærd, som i sidste ende er opbygget af lag af lavere niveau TeX-primitive kommandoer. For bedre at forstå TeXs fundamentale adfærd må vi bruge TeX-primitiver, ikke LaTeX-makroer. ### Hvor er vi på vej hen? Grundlæggende arbejder vi mod en forklaring af makroer som en specialiseret form for tokenliste: når du beder TeX om at definere en makro, opretter det en sekvens af tokens (en tokenliste) og gemmer dem i sin hukommelse knyttet til et navn, som du definerer. I delene 5 og 6 vil vi se nærmere på makro-tokenlister, men hvis du hellere vil hoppe videre fra denne artikel for at læse nogle baggrundsoplysninger, kan du finde det i [Hvad er en TeX-tokenliste?](/latex/da/dybtgaende-artikler/54-what-is-a-tex-token-list.md) Tokenlister for makroer, og deres parametre, indeholder et par ekstra finesser, som vi gennemgår i detaljer – og bruger masser af eksempler til. For bedre at forstå TeXs makrobehandlingsadfærd(er) er der virkelig én nøglefaktor at huske: TeX tænker kun på tegn på det tidligste trin i inputbehandlingen: fra det tidspunkt og frem er det tokens hele vejen! Gennem denne og de øvrige artikler i denne serie vil vi udforske den rolle, tokens spiller i TeX-makroer. ## De fire dele af en makro ### Påmindelse: makroparametre og makroargumenter Før vi starter, er det værd at minde os selv om forskellen mellem en makros *parametre* og en makros *argumenter*, fordi vi kommer til at bruge begge begreber gennem hele denne artikel. Antag, at du definerer en makro \foo ``` \def\foo#1#2{Dette er #1, dette er #2} ``` Konstruktionerne (tokens) `#1`, `#2` (op til `#9`) kaldes makroens *parametre*: tænk på dem som ”pladsholdere” for de faktiske data, du vil bruge, når du kalder makroen: ``` \foo{alpha}{beta} ``` Her, `alpha` og `beta` er de *argumenter* der bruges med dette kald af \foo: en makros argumenter er de faktiske værdier, der føres ind i parameter-pladsholderne (`#1`, `#2`... `#9`) der blev brugt, da du definerede makroen. ### Makrodefinition: har 4 elementer Vi starter med noget, der måske ligner en lidt formel definition af en makro, men det giver en nyttig ramme for videre diskussion. Enhver makrodefinition består af 4 dele: ``` {} ``` hvor: * ``: en af `\def`, `\edef`, `\gdef` eller `\xdef`; * ``: navnet, der gives til din makrokommando, såsom `\foo`; * ``: dette kan mangle, men hvis der er et, er det en række af *tokens* der optræder før `` af makroen. Den `` kan indeholde makroparametre (`#1`, `#2`... `#9`) og andre tokentyper. I bund og grund, og som vi vil se i detaljer, `` giver det en slags *token-skabelon* som TeX bruger til at finde ud af, hvilke tokens brugeren vil bruge som makroens argumenter: når du kalder en makro, føder TeX *(i praksis “tegnsætning”) og hvilke* tokens ind i din makros `` (som også er en tokenliste); * `{}`: dette er selve brødteksten i din makro: det er en række tokens, som *argumenter* ”indsættes”, når makroen behandles (udvides). Argumenterne føres ind i de positioner, der angives af makroparametre brugt i den oprindelige definition. **BEMÆRK**Gennem hele diskussionen antager vi, at `` følges af et mellemrumstegn med kategori-kode 10, som fungerer som en afgrænser til at afslutte ``. Vi *har ikke* vist dette mellemrumstegn eksplicit i vores tekst/diskussion, men vi antager, at det er der. Strengt taget burde vi repræsentere det nogenlunde sådan her: ``` {} ``` Vi vil dog undlade den eksplicitte medtagelse af et `` tegn og implicit antage, at det er til stede. #### Bemærkninger om {} Vi har vist brugen af to krøllede parenteser: `{` og `}` som omslutter (afgrænser) selve brødteksten i din makros ``. Brugen af `{` og `}` er dog blot en vedtaget konvention, fordi det, TeX faktisk forventer, er teksten i din makro `` at åbne med et tegn med kategori-kode 1 (”Start en gruppe”) og slutte med et tegn med kategori-kode 2 (”Afslut en gruppe”). Ifølge konventionen er disse `{` og `}` tegnene henholdsvis. Du kan dog, hvis du ønsker det, tildele ethvert par tegn til at gøre det. For eksempel ``` \catcode`\(=1 \catcode`\)=2 ``` Nu kan du definere og bruge makroer sådan her: ``` \def\foo #1(Hej, #1) \foo(Verden!) ``` Og du kan stadig bruge `{` og `}` fordi vi ikke har ændret deres kategori-koder — flere tegn kan, og gør det, have samme kategori-kode, så du kan fortsætte med at definere makroer på den sædvanlige måde: ``` \def\foo #1{Hej, #1} \foo{Verden!} ``` ### og {} De komponenter i en makrodefinition, som er mest relevante for vores diskussion, er `` og `{}`. Når du definerer en makro, er `` i virkeligheden en streng token-skabelon, som definerer, hvordan makroen skal bruges. Som nævnt, `` kan være tom, f.eks. `\def\foo{Noget tekst}` hvor der ikke står noget mellem vores kommandonavn (`\foo`) og den åbne klammeparentes `{` som her markerer starten på vores makros ``. **Bemærk**: Nogle læsere kender måske til TeXs ”hashquote”-mekanisme (`#{`) men det kommer vi ikke ind på her. ### og makroafgrænsere Denne artikel er ikke tænkt som en fuldstændig og grundig gennemgang af at skrive makroer, men det er værd at få en kort genopfriskning med nogle eksempler, der viser, at `` kan blive komplekst, fordi TeX tillader `` at indeholde: * **makroparametre**: (`#1`, `#2`,... `#9`) som fungerer som ”pladsholdere” for værdier, som brugeren vil give, når de kører makroen — makroens *argumenter*; * **afgrænser-tokens**: vilkårlige tokens, indsat mellem/omkring parametertokensene og brugt til at angive grænsen mellem makroparametre. Du kan tænke på disse afgrænsere som en slags ”tegnsætning”, der gør `` til en ”token-skabelon”, som du skal følge, når du bruger makroen. Afgrænsningstokens sættes ikke med i satsen. Så hvad betyder det egentlig — lad os se på nogle eksempler. Den `` sidder mellem makroens navn og den venstre krølleparentes `{` i makrodefinitionen. #### Afgrænsere: Eksempel 1 Antag, at vi definerer en grundlæggende makro `\foo` som følger: ``` \def\foo ABC{hej, der} ``` * `` = `ABC` * Der er ingen parametertokens (`#1`, `#2`,... `#9`) * Afgrænserne er de *tre tegntokens* `ABC` men i dette eksempel er de noget overflødige og bruges blot som et eksempel. De tre tegntokens `ABC` behandles som afgrænsere: ikke noget, der skal sættes i sats, men ”tegnsætning”, som forventes at være til stede, når makroen kaldes — når du bruger makroen `\foo` skal du levere de samme afgrænsere, som var til stede, da den blev defineret. Hvis du skriver `\foo ABC` i din tekst, vil dette sætte `hej, der`—tegn-tokensene `ABC` sættes ikke i sats, men TeX kontrollerede meget omhyggeligt, at de var til stede i dit kald af `\foo`. TeX leder efter disse afgrænsere (”tegnsætning”) og fjerner (absorberer) dem, som du kan se i det følgende Overleaf-skærmbillede: `ABC` sættes ikke i sats: ![Overleaf, der kører en TeX-makro](/files/0ea2c484da3bafc92864894d5ae40c94be36d1ea) Hvis du prøver at bruge `\foo` uden `ABC` afgrænserne, vil TeX klage `Brugen af \foo stemmer ikke overens med dens definition.`: ![Visning af en TeX-fejl på Overleaf](/files/3c2b09bf7344fbbca3c0d11c55ce219910e7fd95) I eksemplet ovenfor, efter at have registreret `\foo` forventer TeX at se de tre tegntokens `ABC` men det gør den ikke: den ser tegntokenet for `w` og registrerer straks, at noget er galt. #### Afgrænsere: Eksempel 2 Et interessant og måske overraskende faktum er, at afgrænsere kan være vilkårlige kommandotokens — herunder kommandoer, der ikke engang er *defineret endnu*. For eksempel kunne vi definere `\foo` som: ``` \def\foo A\bob B\anne{Hej \TeX{}} ``` * `` = `A\bob B\anne` * Der er ingen parametertokens (`#1`, `#2`,... `#9`) * Afgrænserne er tokensene `A\bob B\anne` men igen er de i dette eksempel overflødige og kun til diskussionsformål. Bemærk, at `\bob` og `\anne` er fiktive kommandoer, som var *ikke defineret*—og behøver ikke at være det. Når du kalder en makro, kontrollerer (scanner) TeX `` det, som er til stede *i dit makrokald* og sammenligner det token for token med versionen af ”token-skabelonen” *gemt i hukommelsen*—den, der blev oprettet på det tidspunkt, hvor makroen blev defineret. TeX scanner *brugt i dit makrokald* og omdanner blot alle kommandoer, den finder dér, til deres numeriske tokenværdi: den forsøger ikke at udføre disse kommandoer, så det betyder ikke noget, at `\bob` og `\anne` aldrig var defineret. TeX bruger blot token-skabelonen, der er gemt i hukommelsen, som en vejledning, der gør det muligt at finde ud af, hvilke tokens i `` i dit makrokald der er de faktiske argumenter, som skal føres ind i ``. Som du kan se af det følgende Overleaf-skærmfragment, blev ingen af tegntokensene (`Et` og `B`) i `A\bob B\anne` blev sat i sats, og vores udefinerede kommandoer `\bob` og `\anne` forårsagede ingen problemer. Alle disse tokens blev *absorberet* af TeX, mens den matchede din brug af `\foo` med definitionen (token-skabelonen) af `\foo` (en tokenliste) gemt i hukommelsen. ![Overleaf, der kører en TeX-makro](/files/f56b7c1359ec52371cad571bde4175d2512f1c4f) #### Afgrænsere: Eksempel 3 Du kan indsætte forskellige afgrænsere (tegntokens, kommandotokens) mellem makroparametre, som i dette eksempel: ``` \def\foo A\bob#1B\anne#2\jane#3bye!{Hej fra \TeX{} til \#1=#1, \#2=#2 og \#3=#3} ``` * `` = `A\bob#1B\anne#2\jane#3bye!` * Der er 3 makroparametertokens: `#1`, `#2`, `#3` * Denne gang er parametrene (`#1`, `#2`, `#3`) afgrænset af en kombination af tokens: `A\bob#1B\anne#2\jane#3bye!` Her har du i virkeligheden givet TeX en skabelon, som det meget omhyggeligt vil forsøge og forvente at matche, når du kalder `\foo`: den vil gennemgå dit makrokald, *token for token*, og forvente at matche (finde): * de to tokens `Et` og `\bob` før `#1` * de to tokens `B` og `\anne` før `#2` * tokenet `\jane` før parameter `#3` og *fire tegntokens* `b`, `y`,`e` og `!` efter `#3`. **Husk**: TeX tænker i tokens, så `farvel!` er *fire tegntokens*. Der er to måder, vi kan bruge denne makro på — vi kunne sætte eventuelle fler-token-argumenter i krølleparenteser for at danne en gruppe: ``` \foo A\bob{Dette}B\anne{Det}\jane{Andet}farvel! ``` Det er dog *ikke nødvendigt* fordi vores makrodefinition har afgrænsere, som giver en token-skabelon. TeX kan bruge den skabelon til at udvælge tokenene for hvert argument blandt tokens, der udelukkende er afgrænsere. Vi kan bruge vores makro sådan her: ``` \foo A\bob DetteB\anne Det\jane Andetfarvel! ``` og TeX kan udvælge argumenterne for at give det samme resultat som ved brug af grupper `{...}`: ![Overleaf, der kører en TeX-makro med afgrænsere](/files/a0ad5a1e87f11c54763b8b0e80a8c4541945161c) Bemærk, hvordan TeX præcist kunne registrere, hvilke tokens der matchede parametre `#1` og `#3`: ![Overleaf, der kører en TeX-makro med afgrænsere](/files/e6f2fe9b5a37c9c968ad4a153dd6f2408a7e7586) #### Afgrænsere: Eksempel 4 (det handler om tokens, ikke tegn!) Her er et kort eksempel, der viser, at når man arbejder med makroer, er det vigtigt at huske, at vi virkelig befinder os i en verden af *tokens* og **ikke** *tegn*… Vi definerer den følgende korte makro, hvor A og B er tegn, der fungerer som afgrænsere, og begge har kategori-kode 11. Dette virker uden problemer: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hej, #1} \foo AGrahamB \end{document} ``` og sætter i sats `Hej, Graham`. Men hvis du ændrer kategori-koden for A eller B til noget andet end 11, vil makrokaldet fejle. Antag, at vi ændrer kategori-koden for B til 12 ved at bruge ``\catcode`B=12`` og forsøger at kalde makroen igen som før: ``` \documentclass{article} \begin{document} \def\foo A#1B{Hej, #1} \foo AGrahamB % Dette virker \catcode`\B=12\relax \foo AGrahamB \end{document} ``` Det fejler med en noget forvirrende fejl: ``` Løbsk argument? GrahamB \end {document} ! Filen sluttede, mens brugen af \foo blev scannet. \par <*> main.tex Jeg mistænker, at du har glemt en `}', hvilket får mig til at læse forbi det sted, hvor du ønskede, at jeg skulle stoppe. Jeg vil prøve at komme mig; men hvis fejlen er alvorlig, bør du hellere skrive `E' eller `X' nu og rette din fil. ! Nødstop. <*> main.tex *** (job afbrudt, ingen gyldig \end fundet) ``` ![Overleaf viser en TeX-makrofejl](/files/e5441deb9347c82c9ba676b885f16edc0237c9ea) Desværre er TeXs standardsuggestion om ``Jeg mistænker, at du har glemt en `}'`` er **forkert**, skyldes den ikke en manglende klammeparentes (`}`). #### Hvad er der sket? TeX forsøger at matche `\foo` makro *kaldet* med `\foo` makro *definitionen* som det har gemt i hukommelsen. Når du kalder en makro, der har brug for ét eller flere argumenter, må TeX undersøge (scanne) din brug af makroen for at finde ud af *argumenter* du leverer til den makro. Her forventer TeX, at argumentet er klemt inde mellem et A (kategori-kode 11) og et B (kategori-kode 11). Husk: TeX tænker i *tokens*, **ikke** *tegn*. Tokenværdierne for A og B, $$\mathrm{T\_A}$$ og $$\mathrm{T\_B}$$ henholdsvis, er: $$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$ Men efterhånden som TeX fortsætter sin søgning, ser den B’et *men* nu har det kategori-kode 12, og det giver en anden tokenværdi: $$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$ I `\foo` makrodefinition var tokenværdien for B (brugt som afgrænser) 2882, men TeX ser nu en tokenværdi på 3138: den tror, at dette blot er endnu et token, der er bestemt til brug i *(i praksis “tegnsætning”) og hvilke* som gives til `\foo`. Så vidt TeX angår, er det sidste token i argumentet endnu ikke fundet, så den går videre for at hente endnu et token i sin søgen efter et B med kategori-kode 11. Det er dér, og derfor, makroen fejler: i sit forsøg på at finde argumentet ”overstyrer” TeX og begynder at læse tokens, som du ikke havde tænkt skulle blive en del af argumentet til `\foo` makrokaldet. Hvad der sker derefter, afhænger af de tokens, TeX opdager efter B’et — de vil udløse forskellige `Løbsk argument?` fejl. I vores eksempel overstyrer TeX og forbruger tokenstrømmen `\end {document}` og rammer hurtigt filens slutning, og derfor fejlmeddelelsen: ``` ! Filen sluttede, mens brugen af \foo blev scannet ``` ## Del 5 Som vi så ovenfor, kan `` sektionen i vores makrodefinition variere fra ekstremt enkel til en kompleks blanding af makroparametre, indsat mellem tegntokens og kommandotokens, der fungerer som afgrænsere. TeX kan behandle de forskellige kombinationer af tokens, der er til stede i `` for at udtrække de argumenter, der gives til en makro — og opdage, når vi forsøger at bruge en makro forkert. Hvordan den gør det, er emnet for næste artikel i serien. [Del 1](/latex/da/flere-emner/19-how-tex-macros-actually-work-part-1.md) [Del 2](/latex/da/flere-emner/20-how-tex-macros-actually-work-part-2.md) [Del 3](/latex/da/flere-emner/21-how-tex-macros-actually-work-part-3.md) [Del 4](/latex/da/flere-emner/22-how-tex-macros-actually-work-part-4.md) [Del 5](/latex/da/flere-emner/23-how-tex-macros-actually-work-part-5.md) [Del 6](/latex/da/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/da/flere-emner/22-how-tex-macros-actually-work-part-4.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.