> 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/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Hvordan virker \expandafter: En introduktion til TeX-tokens [Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Baggrund for \expandafter: TeX-tokens og tokenlister Som et første skridt mod at forstå, hvordan `\expandafter` det faktisk fungerer, vil vi se på to komponenter i TeX, som er grundlæggende for driften af `\expandafter`: TeX-tokens (heltal) og tokenlister (lister af heltal). Læsere, der gerne vil udforske disse emner meget mere detaljeret, kan have interesse i at læse følgende artikler udgivet af Overleaf: * [Hvad er et TeX-token?](/latex/da/dybtgaende-artikler/53-what-is-a-tex-token.md) * [Hvad er en TeX-tokenliste?](/latex/da/dybtgaende-artikler/54-what-is-a-tex-token-list.md)-[Hvordan virker TeX-makroer egentlig?](/latex/da/flere-emner/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### Hvor kom tokendataene fra? Gennem hele denne artikel bruger vi faktiske tokenværdier beregnet af TeX—data, som normalt ikke er tilgængeligt for brugere. For læsere, der er nysgerrige efter at vide, hvordan disse data om tokenværdier blev indhentet, har Overleaf tilpassede builds af flere TeX-motorer, som vi bruger til forskning. Disse motorer er ændret, så de udskriver oplysninger om TeX’s interne behandlingsaktiviteter—det hjælper med at give supplerende baggrundsmateriale til nogle af de artikler, vi producerer. Ved at vise og diskutere numeriske tokenværdier er vores mål at medtage detaljer, som forhåbentlig hjælper læserne med bedre at forstå “TeX-tokens”, så dette vigtige begreb føles en smule mindre uigennemsigtigt. ## TeX Tokens 101 (og begreber om ekspansion) Når TeX behandler din inputfil, læser den teksten og konverterer enkelte tegn og sekvenser af tegn (kommandoer) til såkaldte *tokens*. Et TeX-token er ganske enkelt en heltalsværdi, beregnet af TeX, som bruges til at “kode” data, som TeX skal gemme om et element, der er læst ind fra dets aktuelle inputkilde. Tænk på tokens som små informationspakker, der “pakker” de data sammen, som TeX skal registrere, klar til at blive sendt videre til næste behandlingsstadium. Internt arbejder TeX på disse heltals-tokenværdier—det bruger ikke de faktiske bogstaver, symboler, cifre osv., der oprindeligt var i din inputfil: alt bliver konverteret til et token (et heltal), og TeX arbejder med dem. ## Hvordan TeX beregner tokenværdier Her ser vi på tokenberegninger, der bruges i Knuths oprindelige TeX, e-TeX og pdfTeX; for andre TeX-motorer, især XeTeX og LuaTeX, skal deres tokenberegninger være en smule anderledes for at tage højde for brugen af Unicode, men beregningsmetoderne ligner dem, der er beskrevet nedenfor. ### Tegntokens (ikke-aktive tegn) Beregningen af tokenværdier for ikke-aktive tegn er ligetil: $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Eksempel**: Bogstavet A med [kategori-kode](/latex/da/flere-emner/43-table-of-tex-category-codes.md) 11, tegnkode 65, repræsenteres af TeX som tegntokenværdien $$256\times 11 + 65 = 2881$$. Du kan støde på beskrivelser i TeX-litteraturen, der bemærker, at når TeX har indlæst et tegn, bliver dets kategori-kode-værdi “permanent bundet” til det tegn: beregningen af tokenværdien ovenfor viser, hvorfor det er sandt. Men senere i TeX's behandling kan det, og gør det, “pakke” tegntokens ud igen for at afsløre det (tegnkode-, kategori-kode-) par, som tokenet blev konstrueret ud fra—når TeX gør denne “udpakning”, ændrer det stadig ikke tegnets kategori-kode, det bruger blot disse oplysninger i den efterfølgende behandling. ### Kommando-tokens TeX's inputbehandling og tokengenerering genkender to typer kommando: * kommandoer konstrueret af et eller flere tegn, der har kategori-kode 11; * enkeltegnskommandoer, hvor det tegns kategori-kode ikke er 11: såsom `\$` eller `\#`. I begge tilfælde udelader TeX det indledende `\` tegn og bruger tegnkoden for hvert resterende tegn til at beregne et heltal, som TeX kalder `curcs` (**nuv**ærende **c**kontrol **s**sekvens). TeX bruger derefter værdien af `curcs` til at beregne en tokenværdi for kommandoen. #### Kommandoer lavet af tegn med kategori-kode 11 Antag, at vores kommando (minus det indledende `\` tegn) er sammensat af en sekvens af tegn: $$\mathrm{C\_1C\_2C\_3...C\_N}$$ hvor $$\mathrm{C}\_i$$ er tegnkoden for hvert tegn—f.eks. er tegnkoden for A 65. TeX bruger alle tegnkoderne $$\mathrm{C}\_i$$ til at beregne heltallet `curcs` (ved hjælp af en [hashfunktion](https://en.wikipedia.org/wiki/Hash_function)). Når TeX har beregnet værdien af `curcs` føjer det simpelthen 4095 til den værdi, hvilket giver tokenværdien: $$\text{command token} = \text{curcs + 4095}$$ Bemærk, at variablen `curcs` spiller en yderst vigtig rolle i TeX's interne behandlingsaktiviteter. #### Enkeltegnskommandoer Tokens til at repræsentere kommandoer såsom `\$`, `\#` osv. er underlagt en lidt anderledes beregning: heltallet `curcs` er nu den enklere beregning: $$\text{curcs} = 257 + \text{character (ASCII) code}$$ For eksempel, med `\$`, $$\text{curcs}=257 + 36 = 293$$. TeX lægger igen 4095 til denne værdi (ved hjælp af $$\text{command token} = \text{curcs} + 4095$$) hvilket resulterer i `\$` at have en tokenværdi $$293 + 4095 = 4388$$. Sammenlignet med kommandoer bestående af tegn med kategori-kode 11 er den eneste forskel her den måde, TeX beregner værdien for `curcs`. **Bemærk**: heltallet `curcs` beregnes ikke for tegntokens: det sættes altid til 0, når TeX opretter eller arbejder med tegntokens. #### Tokens for aktive tegn TeX har begrebet såkaldte *aktive tegn*: ethvert tegn, der er tildelt kategori-kode 13. Tokens for denne særlige tegnklasse er underlagt en anden beregning end almindelige tegn. Mekanismen for aktive tegn gør det muligt for TeX at skabe, hvad der i praksis er en-tegns-makroer, som du kan bruge *uden* uden at skulle sætte et escape-tegn foran det aktive tegn (typisk `\`): det isolerede tegn udløser dets makroadfærd. Det klassiske eksempel er tilde-tegnet (\~), som TeX/LaTeX bruger til ikke-brydende mellemrum, og som kan defineres/aktiveres som følger: ``` \catcode`~=13 %tildel kategori-kode 13 til ~ \def~{\penalty100000\ } % definer ~ til at fungere som en makro ``` Når TeX efterfølgende læser et `~` tegn vil den opdage, at dets kategori-kode er 13, og behandle det som en “mini-makro”. For at beregne et token, der repræsenterer et aktivt tegn, anvender TeX endnu en variation af beregningen af `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ For eksempel har tegnet \~ tegnkode 126, hvilket betyder, at dets repræsentation som aktivt-tegn-tokenværdi beregnes som følger: $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Bemærk, at ligesom kommandoer er tokens, der repræsenterer aktive tegn, > 4095. ### Konsekvenser/noter * Ethvert token, hvis værdi overstiger 4095, kan straks identificeres som et kommando-token—derfor kan TeX meget let opdage, om et bestemt token repræsenterer et tegn eller en kommando. * For enhver tokenværdi kan TeX, når det er nødvendigt, “pakke” det token ud igen for at afsløre det tegn (og dets kategori-kode) eller den kommando, der oprindeligt var til stede i din `.tex` fil, gemt i en makrodefinition eller indeholdt i en anden tokenliste. * Den “mellemliggende” størrelse kaldet `curcs`—som TeX bruger til at beregne kommando-tokenværdier—spiller en vigtig rolle i TeX's lavniveau-behandling. `curcs` fungerer som en “indeksværdi”, som TeX bruger til at gemme/opsøge den aktuelle betydning af en kommando. Givet et hvilket som helst kommando-token, $$\mathrm{T}$$, trækker TeX blot 4095 fra for at få adgang til værdien af `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ I øvrigt gemmer TeX den læsbare streng af tegn, hvorfra et kommando-token genereres—det er afgørende for fejlrapportering og andre kommandoer såsom `\string` hvis ekspansion er den læsbare version af en tokenværdi. Disse læsbare strenge af tegn, der er gemt inde i TeX, bruges/udskrives dog kun, når det anmodes om det: til al anden behandling bruges tokenets heltalsværdi. ## Se på nogle rigtige tokens Bare for at gøre forestillingen om tokens en smule mindre uigennemsigtig, vil vi definere følgende simple makro og se på de tokens, TeX producerer: ``` \def\hello{Hilsner fra \TeX. \hskip 10pt} ``` For `\hello-makroen bruger TeX tegnene` til at beregne en værdi på 3745 for `h`, `e`, `l`, `l`, `o` ; TeX lægger derefter 4095 til for at skabe en tokenværdi på `curcs`(for Knuths TeX, e-TeX eller pdfTeX). $$3745 + 4095 = 7840$$ Efter at have oprettet et token til at repræsentere kommandoen `\hello-makroen bruger TeX tegnene`, `\def` får TeX til at læse de efterfølgende tokens og bruge dem til at oprette en tokenliste, som gemmes som *definitionen* af `\hello-makroen bruger TeX tegnene` kommandoen. Denne gemte definition (tokenliste) kan derefter hentes, når du fortæller TeX at bruge den `\hello-makroen bruger TeX tegnene` kommando. Den følgende tabel oplister de faktiske tokenværdier, der er oprettet for hvert element (tegn, makro eller primitiv), der indgår i `\hello-makroen bruger TeX tegnene` makrodefinitionen—denne liste af tokens (heltal) er det, TeX gemmer i sin hukommelse (som datastruktur kendt som en [kædeliste](https://en.wikipedia.org/wiki/Linked_list)). Læsere, der ønsker at forstå tokenlister mere detaljeret, henvises til Overleaf-artiklen [Hvad er en TeX-tokenliste?](/latex/da/dybtgaende-artikler/54-what-is-a-tex-token-list.md) | | | | ------------------ | ------------------------- | | **TeX-tokenværdi** | **Repræsenteret element** | | 2887 | G | | 2930 | r | | 2917 | e | | 2917 | e | | 2932 | t | | 2921 | i | | 2926 | n | | 2919 | g | | 2931 | s | | 3116 | , | | 2592 | | | 2918 | f | | 2930 | r | | 2927 | o | | 2925 | m | | 2592 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | I tokenlisten ovenfor har tegnene kategori-koder på 10, 11 eller 12. For eksempel: * tegn har kategori-kode 10 og tegnkode 32, hvilket giver en tokenværdi på $$256\times 10 + 32 = 2592$$ * `,` og `.` har kategori-kode 12 og tegnkoderne 44 og 46 henholdsvis, hvilket giver tokens: * token for `,` $$= 256 \times 12 + 44 = 3116$$ * token for `.` $$= 256\times 12+ 46 = 3118$$ Hver gang TeX efterfølgende støder på tokenværdien 7840 (der repræsenterer `\hello-makroen bruger TeX tegnene`) kan det, hvis nødvendigt, “pakke” det token ud igen for at udtrække `curcs` ved den simple beregning $$\text{curcs} = \text{token value} - 4095$$ (se ovenfor). Ved hjælp af værdien af `curcs` kan TeX konsultere sine interne datatabeller for at afgøre, at kommando-token 7840 repræsenterer en makrokommando. Desuden kan TeX også via `curcs`, opslå og hente den gemte definition af `\hello-makroen bruger TeX tegnene`. Når TeX skal behandle token 7840 fuldt ud, dvs. køre `\hello-makroen bruger TeX tegnene` makroen, behøver den ikke længere token 7840: det token har *gjort sit arbejde*—dvs. det fik TeX til at køre makroen `\hello-makroen bruger TeX tegnene`. TeX kan nu kassere token 7840 og hente de tokens, der repræsenterer den definition (tokenliste), der er gemt i hukommelsen. I virkeligheden er `\hello-makroen bruger TeX tegnene` makrokommandoen (token 7840) blevet *fjernet* fra TeX's aktuelle inputkilde og *erstattet* af tokens indeholdt i definitionen af `\hello-makroen bruger TeX tegnene`. Hvad vi netop har beskrevet, er en form for *token-ekspansion*. Den `\TeX` kommandoen (tokenværdi 5235 anført ovenfor), der bruges inden i `\hello-makroen bruger TeX tegnene` er i sig selv en makro, der er konstrueret af flere tokens—så dens definition er også gemt som en tokenliste: | | | | ------------------ | ------------------------- | | **TeX-tokenværdi** | **Repræsenteret element** | | 2900 | T | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3126 | 6 | | 3126 | 6 | | 3127 | 7 | | 2917 | e | | 2925 | m | | 19597 | \lower | | 3118 | . | | 3125 | 5 | | 2917 | e | | 2936 | x | | 6175 | \hbox | | 379 | { | | 2885 | E | | 637 | } | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3122 | 2 | | 3125 | 5 | | 2917 | e | | 2925 | m | | 2904 | X | Hvis vi skulle erstatte `\hello-makroen bruger TeX tegnene` kommandoen med den fuldstændige liste af tokens, hvoraf den er bygget, inklusive `\TeX` makroen, ville det være en ret lang liste—dvs. hvis vi også *ekspanderede* det `\TeX` makroen, ville vi se: ![En liste af tokens gemt i en TeX-makro](/files/0fe6a7e8ea17570f02a0aaba5cfe56164ef7b83c) Grundlæggende ville den enkelte tokenværdi 7840 (for `\hello-makroen bruger TeX tegnene`) ved fuld ekspansion give i alt 51 tokens (heltal), der repræsenterer tegn og primitive kommandoer. I den følgende liste er det tegn eller den kommando, som hvert token repræsenterer, angivet i parentes “(...)”—disse er ikke direkte gemt i TeX's tokenlister og vises for at hjælpe læseren: ``` 2887 (G), 2930 (r), 2917 (e), 2917 (e), 2932 (t), 2921 (i), 2926 (n), 2919 (g), 2931 (s), 3116 (,), 2592 (), 2918 (f), 2930 (r), 2927 (o), 2925 (m), 2592 (), 2900 (T), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3126 (6), 3126 (6), 3127 (7), 2917 (e), 2925 (m), 19597 (\lower), 3118 (.), 3125 (5), 2917 (e), 2936 (x), 6175 (\hbox), 379 ({), 2885 (E), 637 (}), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3122 (2), 3125 (5), 2917 (e), 2925 (m), 2904 (X), 3118 (.), 2592 (), 7943 (\hskip), 3121 (1), 3120 (0), 2928 (p), 2932 (t) ``` For et menneskeligt læsende øje er dette blot en række heltal, men for TeX koder det en stor mængde information. ## Læs tokens nu og gem dem til senere Når TeX læser din input, kan der være tidspunkter, hvor det er nødt til (eller får besked på) at udskyde fuld behandling af et bestemt sæt tokens. Hvis det instrueres til at gøre det, vil TeX, indtil det får besked på at stoppe, fortsætte med at oprette tokens ud fra inputtet, men gemme dem til senere brug—og derefter hente og behandle dem som en del af sine typografiske aktiviteter. Disse gemte tokens gemmes som såkaldte *tokenlister* , som i praksis er TeX's eneste (interne) mekanisme til lagring af tokendata. Vi har allerede set eksempler på tokenlister—de `\hello-makroen bruger TeX tegnene` og `\TeX` makroer, der er anført ovenfor: definitionen af disse makroer gemmes i TeX's hukommelse som lister af tokens. TeX behandler først (udfører) sådanne tokenlister, når du beslutter at kalde disse makroer. Husk også, at hvert token (heltalsværdi) indeholder tilstrækkelig information til, at TeX let kan finde ud af, om hvert token, der er gemt i en makrodefinition, repræsenterer et tegn eller en kommando. ### Gem tokens med tokenregistre Et andet eksempel på tokenlagring er den eksplicitte oprettelse af lister af tokens, der gemmes i såkaldte *tokenregistre*: dedikerede interne lagerområder, som TeX stiller til rådighed for brugere til at gemme tokenlister. TeX-primitiven `\toksdef` er én måde at bruge tokenregistre på; for eksempel, for at bruge tokenregister `100` og referere til det ved hjælp af kommandoen `\mylist`: ``` \toksdef\mylist=100 \mylist={nogle \TeX{} tokens her} ``` `\mylist` er i virkeligheden blot et navn, som du tildeler en liste af tokens gemt i registerplacering `100`. Ligesom en makrodefinition, `\mylist` indeholder følgende tokenliste: | | | | ------------------ | ------------------------- | | **TeX-tokenværdi** | **Repræsenteret element** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Bemærk**: for at afslutte `\TeX` makroen og forhindre den i at opsluge det følgende `` tegn brugte vi et par klammer `{}` lige efter `\TeX`—tokens for `{` (379) og `}` (637) er gemt i tokenlisten. En anden mulighed er at bruge et “kontrol-mellemrum”-token `\` som ville fremgå af tokenlisten som vist nedenfor (med fed): | | | | ------------------ | ------------------------- | | **TeX-tokenværdi** | **Repræsenteret element** | | 2931 | s | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | o | | 2923 | k | | 2917 | e | | 2926 | n | | 2931 | s | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Bemærk, at `` tegn er repræsenteret som en *tegntoken* med værdien $$256\times 10 + 32 = 2592$$ men `\` behandles som et enkeltegns *kommando-token* (værdi 4384), som beregnes ved hjælp af formlerne givet ovenfor: \begin{align\*} \text{curcs} & = 257 + \text{tegn (ASCII)-kode}\\\ & = 257 + 32\\\ &=289\\\ \text{kommando-token for} \left<\text{\\\space}\right> & = \text{curcs + 4095}\\\ & = 289+4095\\\ &=4384\\\ \end{align\*} I det væsentlige `\mylist={nogle \TeX{} tokens her}` siger til TeX: scan venligst min inputfil for at konvertere de følgende tegn/kommandoer til tokens og gem dem til senere brug. TeX vil adlyde og gemme disse tokens i en hukommelsesplacering, du kan få adgang til ved at skrive `\the\mylist`, hvilket instruerer TeX i at indsætte en kopi af de tokens, der findes i tokenregister `\mylist`. TeX-motorer indeholder en række primitive kommandoer, der eksplicit genererer og gemmer tokenlister—såsom `\everyjob`, `\everypar`, `\mark`, og mange andre. [Del 1](/latex/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Del 2](/latex/da/dybtgaende-artikler/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Del 3](/latex/da/dybtgaende-artikler/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Del 4](/latex/da/dybtgaende-artikler/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Del 5](/latex/da/dybtgaende-artikler/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Del 6](/latex/da/dybtgaende-artikler/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/da/dybtgaende-artikler/19-how-does-expandafter-work-an-introduction-to-tex-tokens.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.