> 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/21-how-tex-macros-actually-work-part-3.md).
# Sådan virker TeX-makroer egentlig: Del 3
[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)
## Tid til en pause!
Før vi går videre til næste del af denne historie, skal vi have et tilbageblik: minde os selv om, hvor vi er på vej hen, og samle tankerne for at sikre, at alle de vigtigste idéer er på plads. Som en påmindelse er vores gennemarbejdede eksempel baseret på antagelsen om, at TeX har læst en tekstlinje, der indeholder `Hello World \jobname` og at TeX sætter dette for at opbygge et afsnit.
### Det endelige mål
Vores mål er at udvikle en bedre (dybere) forståelse af TeX-makroers natur og hvordan de fungerer. Men for at nå dertil er vi først nødt til at forstå, hvordan TeX læser en inputfil og behandler tegnene i den. Her er en opsummering af emnerne, vi hidtil har gennemgået.
* TeX læser (scanner) hvert tegn i dit input, og for hvert tegn har TeX to oplysninger:
* **tegnkode**: et heltal, der bruges til at identificere dette tegn, f.eks. når det gemmes i en .tex-inputfil;
* **kategorikode**: et andet heltal, internt i TeX, som det bruger til at tildele betydning til hvert tegn læst fra inputtet.
* Så snart et tegn er læst ind af TeX, bliver hvert tegns kategorikode *permanent* knyttet til det pågældende tegn gennem oprettelsen af et tegntoken:
* TeX bruger en simpel formel til at “pakke” en tegnkode og den tilsvarende kategorikode sammen til et heltal kaldet et tegntoken.
* Du kan ændre betydningen af ethvert tegn, som TeX har *endnu ikke læst ind* ved at tildele en anden kategorikode til ethvert tegn, hvis adfærd du ønsker at ændre — dvs. ændre den måde, TeX behandler det tegn på.
* Omdefinering (remapping) af kategorikoder opnås ved hjælp af TeXs primitive `\catcode` kommandoen.
* Når TeX ser en kategorikode 0, skifter det til en særlig scanningstilstand og begynder at lede efter en kommando: enten et (potentielt) flertalsbogstavs *kontrolord* eller et enkelttegns *kontrolsymbol*.
Indtil nu har vi set på TeXs inputscanningsproces, når den identificerer enkelte tegn og bruger hvert tegns kategorikode til at finde ud af, hvad der skal ske næste gang. Nogle tegn er bare almindelige tekstelementer til satsning (f.eks. kategorikode 11), men vi har også set mellemrumstegn (kategorikode 10) og escape-tegn (kategorikode 0). Der er andre kategorikoder, som vi af hensyn til korthed ikke har set på — såsom kategorikode 1 (“start gruppe”, f.eks., `{`) , kategorikode 2 (“slut gruppe”, f.eks., `}`) og andre. Hver kategorikode spiller sin egen rolle i TeXs inputscanning og den efterfølgende behandling via softwareprocesser/-algoritmerne inde i TeX.
### Tokener: et hurtigt overblik
Begrebet “tokener” er centralt for den måde, TeX fungerer på: du vil se “tokener” nævnt eller refereret i hele TeX-relaterede bøger, artikler og onlinefællesskaber, så det er værd kort at gennemgå dette emne — du kan finde flere detaljer i en tidligere offentliggjort artikel [Hvad er et "TeX-token"?](/latex/da/dybtgaende-artikler/53-what-is-a-tex-token.md)
Vi har allerede set, at TeX omdanner inputtegn til tokener ved at kombinere tegnkoden og kategorikoden til et enkelt sammensat heltal. TeX gør noget lignende for kommandoer: ved hjælp af kommandoens navn beregner det et heltal kaldet en *kommandotoken* (det vil vi udforske mere i detaljer). Som en vejledning kan du tænke på tokener som TeXs måde at “pakke” de ting, det har læst fra inputtet, så de er klar til at blive sendt videre til næste trin i TeXs behandling. At have alle elementer (tegn eller kommandoer) pænt pakket ind i en enkelt numerisk repræsentation gør det lettere at behandle dem videre ned ad kæden. Når TeX f.eks. vil gemme noget af dit input til senere brug, såsom en makrodefinition, behøver TeX blot at gemme din makrodefinition, uanset hvor kompleks den er, som en række heltal, hvor hvert heltal er et token, der repræsenterer et tegn eller en kommando, som udgør en del af (er indeholdt i) din makros definition.
## Hvad så nu?
I den sidste del af Del 2 så vi, hvordan et escape-tegn (kategori 0) sætter TeX i en særlig behandlingstilstand, hvor det leder efter navnet på en kommando. I vores eksempel registrerede TeX tegnrækken `jobname` og vi afsluttede Del 2 på det punkt, hvor TeX skulle til at “gøre noget” med den tegnrække (kommandoens navn). I denne del vil vi se nærmere på, hvad TeX gør derefter.
Når TeX har identificeret, at en bestemt tegnsekvens i din inputfil repræsenterer navnet på en kommando (her, `jobname`) kan TeX, afhængigt af hvad det laver, være nødt til at udføre den kommando. Vi siger “kan være nødt til”, fordi der er tidspunkter, hvor TeX ikke straks vil forsøge at udføre en kommando: for eksempel når det definerer en makro (TeX opbygger tokenlister) — emner vi vil diskutere senere. Men vi vil fortsætte med at følge vores eksempel, hvor TeX sætter et afsnit og *vil*, i denne situation, være nødt til at udføre `\jobname`.
### Fra en tegnrække til at køre en kommando: hvordan?
Først skal vi vende tilbage til Grafik 5b fra Del 2, hvor TeX har identificeret, at en bestemt tegnstreng i inputtet udgør navnet på en kommando: `jobname`. Grafik 5b viser, at TeX må “Kontrollere interne tabeller...”. Hvad betyder det *egentlig*?
En anden, mere detaljeret, beskrivelse af, hvordan TeX “kontrollerer interne tabeller” for at gå fra at have en tegnstreng (f.eks., `jobname`) til at finde ud af præcis, hvad kommandoen er, og hvad den betyder, kan findes i en tidligere artikel [Hvad er et "TeX-token"?](/latex/da/dybtgaende-artikler/53-what-is-a-tex-token.md) Her vil vi opsummere nøgleidéerne, mens vi forsøger at undgå overdreven gentagelse.
Lad os starte med en analogi. Forestil dig, at du læser en bog og støder på et ukendt ord: hvad gør du? I dag er det næsten helt sikkert “griber Google” men lad os antage, at du foretrækker en ældre metode: du griber ud efter en ordbog, som oplister ord og angiver deres betydning(er). TeX har en analog mekanisme: en intern “ordbog”, som oplister alle de kommandoer, TeX aktuelt kender — og “betydningen” af disse kommandoer. Med “betydning” mener vi: hvad slags kommando er det: hvad gør den, plus andre oplysninger, TeX måtte have brug for for at køre den kommando. Bemærk også, at udtrykket “kommando” omfatter alle TeX/LaTeX-makroer skrevet af brugere/TeX-programmører samt de [hundredvis af indbyggede primitive kommandoer](/latex/da/flere-emner/46-tex-primitives-listed-by-tex-engine.md).
Lad os fortsætte med vores ordbogsanalogi. Når vi som mennesker skal slå betydningen af et ord op, søger vi i ordbogen ved hjælp af den alfabetiske ordliste, som ordbogen giver — men sådan fungerer TeX selvfølgelig ikke helt. Hvis vi vender tilbage til vores oprindelige `jobname` eksempel, hvordan finder TeX i sin “ordbog” “betydningen” af `jobname`— og hvad giver den “betydning” egentlig TeX?
I stedet for at give en intern “alfabetisk ordliste” over alle de kommandoer, TeX kender til, gør det noget lidt andet. TeX omdanner hele tegnsekvensen — som findes i navnet på en kommando — til et enkelt heltal, som vil blive brugt til at identificere (repræsentere) den kommando. Internt opretholder TeX en stor “ordbog” over alle kendte kommandoer, hvori det gemmer/lagrer de *heltal* beregnet ud fra kommandonavne — bemærk, at ordbogen ikke gemmer selve de faktiske kommandonavne som sekvenser af bogstaver (kaldet *strenge*). TeX bruger den ordbog til alle sine indbyggede kommandoer (primtiver) *og* den vil også blive brugt til at gemme detaljer om enhver makro (kommando) oprettet af brugere: navnet på din makro omdannes til et heltal, og det heltal bliver “registreret” inde i TeXs ordbog.
Hver gang TeX registrerer en kommando i dit input og har brug for at vide noget om den kommando, omdanner det rækken af tegn i kommandoens navn til et “ækvivalent” heltal og bruger det heltal til at slå kommandoen op i sin “store ordbog”. Programmører blandt jer vil måske gerne vide, at TeX bruger en form for [hashfunktion](https://en.wikipedia.org/wiki/Hash_function) til at udføre den konvertering.
### Grafik 6: Fra tegn til kommandoens betydning
Den følgende grafik viser den rejse, en kommando gennemgår, når TeX omdanner tegnrækken til et ækvivalent heltal, som kaldes **curcs**, og bruger det heltal til at slå kommandoens betydning op i TeXs “store ordbog”. Resultatet af opslaget er to oplysninger: to heltal, kaldet **curcmd** og **curchr**, som TeX kan bruge til at finde ud af præcis, hvad kommandoen gør, og hvordan den efterfølgende udføres.
Internt opretholder TeX en variabel kaldet **curcs** (**nuvæ**rende **c**kontrol **s**sekvens) som bruges til at gemme heltalsværdien af den kommando, TeX aktuelt arbejder med — dvs., **curcs** gemmer det heltallet beregnet ud fra kommandoens navn. Det er ikke hele historien, for der er endnu en detalje: hvis TeX lige har læst/behandlet et tegn og ikke en kommando, vil det sætte **curcs** til værdien 0 for at huske, at det sidste, der blev læst ind, var et tegn og ikke en kommando.
### Hvad kommandoer betyder for TeX
Hvis vi ser på mængden af [indbyggede kommandoer leveret af TeX-motorer](/latex/da/flere-emner/46-tex-primitives-listed-by-tex-engine.md) kan vi se, at nogle af disse kommandoer er tæt beslægtede: de udfører lignende opgaver; for eksempel er der 4 primitive kommandoer, som alle TeX-motorer bruger til at definere (oprette) makroer: `\def`, `\gdef`, `\edef`, `\xdef`. Disse 4 kommandoer definerer alle makroer, men de gør det selvfølgelig lidt forskelligt. Hvis vi tænker på det fra et programmeringssynspunkt: her har vi 4 kommandoer til makrodefinition, som groft sagt gør det samme, men vi er nødt til at vælge imellem dem for at tage højde for deres individuelle adfærd.
For at håndtere dette tildeler TeX to værdier til hver kommando, og disse to værdier er det, TeX forstår som en kommando’s “betydning” (dens rolle/hvad den gør) — de to værdier er interne i TeX, dybt inde i softwaren, og en del af det “indre maskineri”, som ikke er tilgængeligt for brugere. Hver TeX-kommando, uanset om det er et indbygget primitiv eller en brugerdefineret kommando, får tildelt to værdier, som for TeX definerer/klassificerer dens adfærd — hvad den betyder for TeX. Når TeX bruger sin “store ordbog” til at slå en kommando op, vil det finde disse to vigtige oplysninger:
* **kommandokode**: en slags “generel klassifikation”, der angiver, hvilken “type” kommandoen er — såsom en “makrodefinitions”-kommando (en af `\def`, `\gdef`, `\edef`, `\xdef` ); en “boksoprettelses”-kommando (en af `\hbox`, `\vbox` eller `\vcenter` ) og så videre for de hundredvis af kommandoer, som TeX-motorer understøtter. Makroer (brugerdefinerede kommandoer) får også tildelt en kommandokode.
* **kommandomodifikator**: Dette er supplerende information, som giver TeX specifikke oplysninger om en kommando. Makroer (brugerdefinerede kommandoer) får også tildelt en kommandomodifikator — men for makroer spiller kommandomodifikatoren en lidt anden rolle, end den gør for primitiver (for makroer angiver kommandomodifikatoren, hvor makrodefinitionen er gemt i hukommelsen).
Tilsammen identificerer kommandokoden og kommandomodifikatoren hver kommando entydigt. Her er kommandokoderne og kommandomodifikatorerne for makrodefinitionskommandoerne, som de bruges af Knuths oprindelige TeX-software — bemærk, at andre TeX-motorer kan bruge andre værdier, men de følger præcis det samme princip:
| | | |
| -------------- | ----------------------------------------------------------- | ------------------------------------------------------------------ |
| **kommandoen** | kommandoen
kode
| kommandoen
modifikator
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Opsummering: at få styr på alle disse variabler/værdier
På dette tidspunkt er vi oversvømmet af en masse information om værdier, variabler, kommandoværdier og alle mulige detaljer — det kan hurtigt blive forvirrende, så lad os få overblik over, hvad vi ved. Når TeX læser noget fra dit input, er det enten et tegn eller en kommando. Hver gang TeX læser noget fra inputtet, skal det gemme information om det, det netop har læst (scannet):
* For **tegn**: det skal registrere tegnkoden og kategorikoden. Det skal også oprette og gemme tokenværdien, som TeX beregner ud fra disse værdier.
* For **kommandoer**: TeX skal kende den numeriske ækvivalent, **curcs**, som det beregnede ud fra kommandoens navn. Det kan også være nødvendigt at gemme den “betydning”, som det fandt ved at slå kommandoen op i TeXs “ordbog”: kommandokoden og kommandomodifikatoren. Oven i dette skal TeX også beregne en tokenværdi, der repræsenterer denne kommando.
Ja, det er forvirrende: mange variabler og token-idéer flyder rundt, så lad os prøve at få mening i det.
Internt bruger TeX fire globale variabler til at gemme information om det seneste element, som TeX har læst ind (eller aktuelt “arbejder på”) — vi vil ikke gennemgå disse variabler i stor detalje, men kendskabet til deres eksistens hjælper med at give lidt mere baggrund for at forstå, hvad der virkelig sker:
* **curcmd**: (aktuel kommando) en heltalsvariabel. Den bruges til at gemme *aktuelle kommando* værdien for den kommando, der behandles *eller* den gemmer den aktuelle *kategorikode* for det tegn, der behandles;
* **curchr**: (aktuelt tegn) en heltalsvariabel, men det, den gemmer, afhænger af, hvad TeX netop har læst fra sit input:
* **tegn**: Hvis det senest indlæste element er et tegn, **curchr** gemmer den aktuelle *tegnkode*.
* **kommandoen**: Hvis det senest indlæste element er en kommando, **curchr** gemmer den *kommandomodifikator*: supplerende information, som TeX bruger til at understøtte/afklare **curcmd**— fordi, som vi så ovenfor, nogle kommandoer deler samme værdi af **curcmd**
* **curcs**: (aktuel kontrolsekvens) en heltalsvariabel, som gemmer den værdi, der beregnes ud fra tegnrækken i et kommandonavn. **curcs** = 0 hvis det sidste læste element var et enkelt tegn og ikke navnet på en kontrolsekvens (et kommandonavn);
* **curtok**: (aktuelt token) en heltalsvariabel, der indeholder værdien af det aktuelle token — som enten er et kommandotoken eller et tegntoken.
Her er ovenstående information vist som en tabel:
| | | |
| ------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Global variabel brugt inde i TeX:** | **Når TeX scanner et tegn:** | **Når TeX scanner en kommando:** |
| **curcmd** | Gemmer kategorikoden for det aktuelle tegn | Gemmer *kommandokode*— som identificerer den aktuelle kommando’s “type” |
| **curchr** | Gemmer tegnkoden for det aktuelle tegn | Gemmer supplerende data (kaldet *kommandomodifikator*) , som giver yderligere oplysninger om den aktuelle kommando |
| **curcs** | 0 | Et ikke-nul positivt heltal, der beregnes (via en hashfunktion) ved hjælp af tegnrækken i kommandonavnet. Det bruges til at tilgå TeXs “ordbog” for at slå den aktuelle betydning af en kommando op — for at hente dens kommandokode og kommandomodifikator. |
| **curtok** | For 8-bit TeX-motorer beregnes et *karaktertoken* ved hjælp af formlen: $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ hvor $$\text{curcmd}$$ er tegnets kategorikode, og $$\text{curchr}$$ er tegnkoden | For 8-bit TeX-motorer beregnes et *kommandotoken* ved hjælp af formlen: $$\text{curtok}=4095 + \text{curcs}$$ |
### Yderligere noter om det aktuelle token
For tegn opnås den maksimalt mulige tokenværdi ved at bruge den største kategorikode (15) og den største tegnkode, som for 8-bit TeX-motorer er 255. I teorien (for 8-bit TeX-motorer) er den maksimale tegn-tokenværdi, $$\text{curtok}\_{\text{max}}$$, er:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Vi bemærker “i teorien”, fordi kategorikode 15 bruges til at repræsentere et “ugyldigt tegn”, hvilket får TeX til at generere en fejl: et ugyldigt tegn kommer aldrig igennem TeXs inputscanningsproces og bliver derfor aldrig til et tegntoken.
For kommandoer er det aktuelle token ($$\text{curtok}$$) beregnes ud fra $$\text{curtok}=4095 + \text{curcs}$$ men for kommandoer $$\text{curcs}$$ er *altid* ikke nul, og derfor kan TeX let afgøre, hvad et token repræsenterer:
* Hvis $$\text{curtok} > 4095$$ så er det et kommandotoken;
* Hvis $$\text{curtok} < 4095$$ det er et tegntoken.
I praksis bruger TeX tokener, en simpel heltalsværdi, til at “pakke” alle de oplysninger, det behøver at kende om et element læst fra inputtet.
## Del 4
I Del 4 udforsker vi en række eksempelmakroer for at demonstrere rollen og formålet med en makros `` sektion, som fungerer som en “token-skabelon”, der kan konstrueres ved hjælp af afgrænser-tokener.
[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/21-how-tex-macros-actually-work-part-3.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.