> 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/53-what-is-a-tex-token.md).
# Hvad er et "TeX-token"?
## Motivation for en serie om TeX-tokens og relaterede begreber
Motivationen og den anvendte metodik til at producere en serie artikler om TeX-tokens og relaterede begreber diskuteres i denne artikel [En ny artikelserie: TeX-tokens og relaterede begreber—men hvorfor (og hvordan)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Som nævnt i den artikel bygger vi gennem hele denne serie vores diskussioner og forklaringer på indsigter opnået gennem en specialbygget version af Knuths oprindelige TeX-program—vi bruger det til at producere en serie artikler, der har til formål at give enkle beskrivelser og lette at følge forklaringer af centrale TeX-begreber.
## Introduktion: hvad er vores mål?
I denne artikel finder vi ud af præcis, hvad et TeX-token er, ved at følge behandlingsrejsen fra tegn i inputfilen til selve oprettelsen af TeX-tokens. I praksis er det ret komplekst, så vi har reduceret processen ned til dens kerneessens og stræber efter at gøre den let at følge og forstå, samtidig med at den tekniske korrekthed bevares.
Vi begynder med at introducere nogle vigtige interne TeX-begreber: *primitive*, *kommandokoder* og *kommandomodifikatorer*. Derfra bruger vi et meget simpelt makroeksempel til at se præcis, hvordan TeX behandler kommandoen `\def` og det resulterende token, som TeX opretter for at repræsentere den kommando.
Vi afslutter med et kort kig på, hvordan TeX opretter tokens til at repræsentere tegn, og hvordan et tegns `\catcode` bliver permanent knyttet til et tegntoken—noget der ofte nævnes i bøger om TeX, men her ser vi præcis, hvordan det opnås.
Den følgende grafik viser den rejse, vi vil opsummere—fra inputtekst til TeX-tokens:
## Men først: primitiver og kommandokoder
Hver TeX-motor (Knuths TeX, pdfTeX, XeTeX, LuaTeX) forstår en række indbyggede kommandoer: de såkaldte *primitive*—de grundlæggende byggestenskommandoer, som ligger til grund for TeX’s programmerbarhed. De kaldes “primitive”, fordi de, i modsætning til brugerdefinerede makroer, ikke er opbygget af andre kommandoer og ikke kan reduceres yderligere til simplere instruktioner. For Knuths TeX er der cirka 320 primitiver—men vi bør bemærke, at andre TeX-motorer såsom pdfTeX, XeTeX og LuaTeX alle har tilføjet nye kommandoer til Knuths oprindelige program og vil indeholde primitiver, som ikke findes i Knuths TeX-software.
Internt tildeler TeX en numerisk *kommandokode* til alle kommandoer—uanset om de er brugerdefinerede makroer eller indbyggede primitiver. Disse kommandokoder er ikke tilgængelige for TeX-brugeren; de er blot en del af den interne mekanik i TeX’s behandling, men det er nyttigt at kende til dem for senere diskussion af TeX-tokens.
Grupper af kommandoer, der har beslægtet funktionalitet, deler den samme kommandokode. For eksempel `\def`, `\gdef`, `\edef` og `\xdef` bruges alle til at definere makroer og deler kommandokoden 97 (i Knuths TeX). Det er tydeligt, at de 4 makrodefinitionskommandoer hver især opretter makroer på en lidt forskellig måde; derfor har TeX under behandlingen brug for en måde at skelne mellem dem på.
En kommandokode alene (som 97) kan ikke fortælle dig, hvilken makrooprettelseskommando der er tale om; så som forventet tildeles hver TeX-kommando et ekstra stykke information, kaldet dens *kommandomodifikator* (se eksempler nedenfor).
### Kommandomodifikatorer: to typer
Kommandomodifikatorer falder i to kategorier, som vi vil omtale som “Type 1” og “Type 2”—TeX bruger ikke denne terminologi; det er blot praktisk at gøre det her:
* **Type 1**: Enkle heltalsværdier, som TeX om nødvendigt kan bruge til at skelne mellem kommandoer, der deler den samme kommandokode.
* **Type 2**: En heltalsværdi, der er en numerisk placering i TeX’s hukommelse, som fortæller TeX, hvor det skal gå hen for at slå oplysninger om den pågældende kommando op. Dette gælder for eksempel brugerdefinerede kommandoer (makroer), hvor kommandomodifikatoren fortæller TeX, hvor makrodefinitionen er lagret i hukommelsen.
#### Type 1-kommandomodifikatorer (et eksempel)
Som nævnt har de fire primitive kommandoer til at definere makroer i Knuths TeX: `\def`, `\gdef`, `\edef`, `\xdef` alle kommandokoden 97: de adskilles gennem deres kommandomodifikatorer, som er angivet i følgende tabel:
| Kommando | Kommando
kode
| Kommando
modifikator
|
| -------- | ----------------------- | ------------------------------ |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
Som et andet eksempel valgte Knuth at implementere kommandoerne `\openout`, `\write`, `\closeout`, `\special`, `\immediate` og `\setlanguage` som “udvidelser” til TeX, udelukkende for at vise, hvordan man kan tilføje nye primitiver til TeX. I dette tilfælde deler disse kommandoer egentlig ikke “lignende funktionalitet”, bortset fra at Knuth besluttede at gruppere dem sammen for at forklare, hvordan TeX kan udvides. Disse 6 kommandoer klassificeres som “udvidelser” og grupperes sammen med kommandokodeværdien 59, men hver enkelt har en passende kommandomodifikator, der adskiller den fra de andre:
| Kommando | Kommando
kode
| Kommando
modifikator
|
| -------------- | ----------------------- | ------------------------------ |
| `\openout` | 59 | 0 |
| `\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Type 2-kommandomodifikatorer (en kort forklaring)
Selv om alle kommandomodifikatorer er heltal, kræver Type 2-modifikatorer lidt mere forklaring. Disse kommandomodifikatorer omtales i TeX som “pegepinde”, fordi de peger på en placering i hukommelsen, hvor TeX kan finde yderligere oplysninger om den pågældende kommando. Det kan lyde lidt uklart, men den måde TeX bruger disse pegepinde til at slå oplysninger op på, er ret forskelligartet, og en mere udførlig forklaring ville aflede opmærksomheden fra artiklens hovedformål. Ét eksempel kan hjælpe: makroer. Når en makrokommando defineres, skal TeX gemme erstatningsteksten et sted i hukommelsen. Som vi ser nedenfor, har brugerdefinerede makroer kommandokoder mellem 111 og 114 med en kommandomodifikator, der er en pegepind ind i hukommelsen, som fortæller TeX, hvor dens erstatningstekst (makrodefinitionen) er lagret.
### Kommandokoder: udvidelige og ikke-udvidelige
I Knuths kildekode til TeX varierer kommandokoderne fra 0 til 120—bemærk, at nogle koder inden for dette interval udelukkende er til specialiseret intern brug og ikke er tildelt kommandoer, som er tilgængelige for brugeren. Det er værd at bemærke, at andre TeX-motorer såsom pdfTeX, XeTeX og LuaTeX alle har tilføjet nye kommandoer til Knuths oprindelige sæt og vil indeholde flere primitiver og tilsvarende kommandokoder; principperne, der skitseres her, er dog centrale for alle TeX-baserede motorer, der er afledt af Knuths kildekode.
Samlingen af kommandokoder er opdelt i to hovedsæt:
* *ikke-udvidelige kommandoer*: har kommandokoder mindre end eller lig med 100;
* *udvidelige kommandoer*: har kommandokoder større end 100, op til en maksimumværdi på 120. Intervallet 101 til 120 omfatter brugerdefinerede makroer samt kommandoer som `\csname`, `\expandafter` og `\the`.
Ikke-udvidelige kommandoer udfører typisk tildeling af en værdi til en intern parameter eller frembringer direkte materiale, der kan sættes. Udvidelige kommandoer “indsprøjter” typisk en strøm af tokens i TeX’s aktuelle behandlingsaktivitet eller ændrer rækkefølgen af tokenbehandlingen.
Som nævnt ovenfor tildeles alle makroer (brugerdefinerede kommandoer) kommandokoder mellem 111 og 114: de forskellige værdier afspejler, om makroen blev defineret som `\long`, `\outer`, begge dele eller ingen af delene. Her er et eksempel:
| Makrotype | Eksempel | Bemærkning |
| --------------------- | ------------------------------ | -------------------------- |
| Ikke-long, ikke-outer | `\def\ohyeah{....}` | `\ohyeah` kommandokode=111 |
| Long, ikke-outer | `\long\def\ohyeah{....}` | `\ohyeah` kommandokode=112 |
| Ikke-long, outer | `\outer\def\ohyeah{....}` | `\ohyeah` kommandokode=113 |
| Long outer | `\long\outer\def\ohyeah{....}` | `\ohyeah` kommandokode=114 |
Som en påmindelse om kommandomodifikatorer vil TeX, når en makro defineres, gemme makroens definition et sted i hukommelsen: den placering (en pegepind) bliver kommandomodifikatoren for makrokommandoen, som vil blive gemt med en kommando fra 111 til 114 afhængigt af, hvordan den blev defineret. Det faktiske navn, der tildeles en brugerdefineret makro, betyder i virkeligheden ikke så meget: efter behandlingen af inputtet vil de alle få tildelt en kommandokode fra 111–114, og i sidste ende bliver alle kommandoer, som TeX læser fra dit input, hvad enten de er primitiver eller brugerdefinerede makroer, omdannet til en numerisk repræsentation kaldet en *token*.
## Rejsen fra inputtekst til TeX-tokens
I dette afsnit bruger vi et meget simpelt makroeksempel til at se præcis, hvordan TeX behandler kommandoen `\def` for at oprette et token, som repræsenterer `\def` kommando. TeX’s detaljerede behandlingsaktivitet kan være ekstremt kompleks, så vi bruger ikke makroparametre eller skilletegn, fordi det ville tilføje kompleksitet og aflede opmærksomheden fra vores rejse.
Antag, at din TeX-inputfil indeholder følgende linje:
```latex
\def\ohyeah{Overleaf is cool!}
```
Når TeX begynder at behandle denne inputlinje, tjekker den `\catcode` for hvert tegn og ser, at det første tegn er `\` (første tegn i `\def`). Den registrerer (slår det op i en intern tabel), at `\` har `\catcode` 0, hvilket betyder, at det indleder starten på en *kontrolsekvens*. Selvfølgelig kan du omdefinere ethvert tegn til at have `\catcode` 0, men vi antager, at de konventionelle definitioner af plain TeX eller LaTeX bruges.
Strengt taget har termen *kontrolsekvens* to underkategorier: *kontrolord* og *kontrolsymbol*:
* *kontrolord*: en sekvens af tegn med `\catcode` bogstav (11);
* *kontrolsymbol*: et enkelt tegn, hvis `\catcode` er *ikke* bogstav er (11).
På dette tidspunkt har `\` tegn gjort sit arbejde og er nu færdigt. Når TeX registrerer et escape-tegn, er dets reaktion at begynde at læse alle efterfølgende tegn i inputtet med henblik på at opdage et kontrolord eller et kontrolsymbol.
Efter det indledende `\`, registrerer TeX straks `d`: et tegn, hvis `\catcode` er 11, hvilket fortæller TeX, at det har fundet det første bogstav i et *kontrolord*. Den fortsætter med at scanne efterfølgende tegn, indtil den endelig registrerer et tegn, der *ikke* har `\catcode` bogstav (11). Alle efterfølgende tegn (efter det indledende `\`) `\catcode` 11 (bogstav) betragtes som dannende navnet på et kontrolord: dvs. navnet på en kommando—måske en makro eller et primitiv, men TeX har endnu ingen anelse om, hvilken type kommando det er. På dette tidspunkt er det blot en streng af tegn.
Så i vores eksempel scanner TeX gladeligt videre og tjekker hvert tegn, indtil det når det indledende `\` af `\ohyeah` som også har `\catcode` 0. TeX erkender, at det har scannet for langt, og returnerer høfligt det `\` tilbage i tekststrømmen, så det bliver det næste tegn, der ses under yderligere scanning af teksten. På dette tidspunkt har TeX identificeret en streng (`def`) som den ved udgør teksten i et kontrolord bestående af tre tegn, hver med `\catcode` 11 (`d`, `e` og `f`). Hvad TeX nu skal gøre, er at finde ud af, hvad `def` betyder: hvad skal det gøre? Som du måske har gættet, skal TeX finde kommandokoden og kommandoidentifikatoren for `def` så den kan finde ud af, hvad den skal gøre med denne kommando.
## At lave hash af det
Efter at have registreret et kontrolord (`def`), er det første, TeX gør, at “omdanne” tegnstrengen (`def` i vores eksempel) til et heltal ved at bruge noget, der kaldes en hashfunktion. Vi behøver ikke at bekymre os for meget om detaljerne; en oversigt er tilstrækkelig. I det væsentlige ser TeX på hvert tegn i kontrolordet, det netop har registreret, og bruger ASCII-kodeværdien (eller Unicode-værdien for XeTeX/LuaTeX) for hvert tegn til at beregne et tal kaldet en hashværdi: det er blot et simpelt heltal.
Som en del af denne hashberegningsproces vil TeX også kontrollere, om tegnstrengen i det nyopdagede kontrolord allerede er kendt for det. Den læsbare tekst for alle kommandoer, hvad enten de er primitiver eller brugerdefinerede makroer, gemmes i et internt lagerområde kaldet *string pool*. TeX er nødt til at gøre dette, fordi det kan få brug for at udskrive en kommando i læsbar form—for eksempel når TeX skal rapportere en fejl og angive navnet på den fejlbehæftede kommando. For eksempel vil vores makro `\def\ohyeah{Overleaf is cool!}` definerer en ny kommando kaldet `\ohyeah` og TeX skal (på et senere tidspunkt) ikke blot beregne en hashværdi for `ohyeah` (*uden* det indledende `\` tegn) men også gemme tekststrengen (i læsbar form), hvis den får brug for at anvende den til fejlrapportering (eller andre opgaver).
Hvis du vil have flere detaljer om TeX’s håndtering af strenge, har jeg skrevet om dette på min [personlige blog](http://www.readytext.co.uk/?p=3590).
Det endelige resultat er, at tegnstrengen, der repræsenterer kommandoen `def` omdannes til den numeriske værdi 1218 (det er den faktiske værdi beregnet af TeX). På dette tidspunkt er de enkelte tegn `d`, `e` og `f` ikke længere en del af hovedhistorien—de er blevet læst fra inputtet og har gjort deres arbejde: fra nu af handler det hele om heltal og *tokens*—vi vil snart se, hvad et token faktisk er! Internt omtaler TeX disse hashværdinumre som den *aktuelle kontrolsekvens* men i kildekoden forkortes dette udtryk til en variabel kaldet `curcs`. TeX’s kildekode er fuld af meget korte, ofte ret kryptiske, variabelnavne.
Men hvad gør TeX *egentlig* med denne nyfrembragte heltalsværdi 1218? Hvordan finder TeX ud af, at den oprindelige streng `def`, nu repræsenteret ved heltallet 1218, faktisk henviser til en instruktion om at definere en makro? Svaret er, at TeX har en slags internt “kartotek”, hvor det gemmer den aktuelle betydning og værdi af hver kommando, det i øjeblikket kender—uanset om den kommando er en brugerdefineret makro eller et indbygget primitiv. Grunden til, at TeX gik så meget op i at omdanne `def` til hashværdien 1218 (nu gemt i variablen kaldet `curcs`curcs *betydning* af `def`. TeX vil naturligvis gentage denne hashberegning for alle kontrolord, det registrerer i inputtet—selvfølgelig giver forskellige kontrolord forskellige heltalsværdier fra hashfunktionen: det er hele pointen.
TeX’s interne “kartotek” kaldes *ækvivalenstabellen* og er emnet for næste afsnit.
### Opslag i ækvivalenstabellen
Lad os lige opsummere, hvad vi indtil videre har lært:
* `\` indfører begyndelsen på en kontrolsekvens (enten et *kontrolsymbol* eller et *kontrolord*).
* Hvis det første tegn efter `\` har `\catcode` 11 (bogstav), så er det begyndelsen på et *kontrolord*.
* For *kontrolord* TeX scanner for at kontrollere alle efterfølgende inputtegn, der har `\catcode` 11 og vil stoppe scanningen, så snart det finder det første tegn, der ikke *ikke* har et `\catcode` på 11.
* Tegnsstrengen af inputtegn (efter `\`) som har `\catcode` 11, betragtes som et *kontrolord* som brugeren har skrevet: en kommando, der beder TeX om at “gøre noget”.
* For at begynde processen med at “gøre noget” omdanner TeX tegnstrengen i kontrolordet til et heltal. Det gør den ved hjælp af en såkaldt hashfunktion, som giver et heltal som output.
* Heltallet (den beregnede hashværdi) omtales som *aktuelle kontrolsekvens*, men TeX giver det det kortere navn `curcs`.
* I vores eksempel bliver kontrolordet `def` omdannet til værdien 1218—som lagres i en variabel kaldet `curcs`: dvs., `curcs=1218`.
TeX skal nu finde ud af, hvad det nyopdagede *aktuelle kontrolsekvens* egentlig betyder—hvad gør TeX med det?
#### En note om gruppering: behovet for at gemme og gendanne oplysninger
Her tager vi en lille omvej for at minde os selv om, at TeX har evnen til at gemme og gendanne oplysninger: dvs. at det har en form for indbygget “hukommelse”.
Enhver, der har skrevet bare den enkleste makro, bør kende til TeX’s grupperingsmekanisme—for eksempel ved at bruge `\def` til at oprette makroer inden for en gruppe. Medmindre du anvender `\global` præfikset til `\def`-oprettede makroer defineret inden for en gruppe, består makroens værdi eller betydning kun inden for den gruppe (og dem under den): dens definition går tabt, når gruppen afsluttes. Hvis du for eksempel definerer en simpel makro inde i en gruppe, sådan her:
```latex
{\def\foo{Hello}}
```
og forsøger at bruge `\foo` uden for gruppen
```latex
{\def\foo{Hello}}% \foo defineret inden for en gruppe (bemærk: ingen brug af \global)
\foo %<--- ikke længere defineret, nu udefineret
```
så får vi den velkendte fejl: `Udefineret kontrolsekvens`. `\foo` har kun betydning inde i den gruppe (og dens undergrupper), hvor den blev defineret. Desuden kan den nye værdi gå tabt, når du omdefinerer en makro inde i en gruppe, når gruppen slutter, og den tidligere betydning (som eksisterede uden for gruppen) gendannes.
```latex
\def\foo{Goodbye}
\foo\par% Udskriver Goodbye
{\def\foo{Hello}% Omdefineret inde i en gruppe:
{Inde i gruppe på 2. niveau: \foo\par}}% Brugt inde i gruppe på 2. niveau: \foo udskriver Hello
Uden for gruppen gendannes den gamle værdi: \foo\par% Udskriver Goodbye
```
Formålet med disse simple eksempler er at pege på, at TeX har en form for “lagringsmekanisme” eller “hukommelse”, som gemmer/gendanner kommandoers “betydning”—og det har den selvfølgelig. Vi antydede dette i forrige afsnit: denne “lagringsmekanisme” eller dette “kartotek” er en stor intern tabel kaldet *ækvivalenstabellen*. Det er dér, TeX gemmer den aktuelle betydning eller værdi af alle de kommandoer, det i øjeblikket kender—de indbyggede primitiver og brugerdefinerede makroer.
### Ækvivalenstabellen: ved analogi
For at forklare ækvivalenstabellen vil vi gå frem ved analogi. Vi vil fortsat bruge forestillingen om et kartotek med tusindvis af små skuffer, hver mærket med et unikt heltal. På dette tidspunkt i behandlingen siger TeX i praksis:
“OK, jeg har denne heltalsværdi 1218, som jeg lige har beregnet og gemt i en variabel kaldet `curcs`. Nu skal jeg finde ud af, hvad den betyder: for at gøre det går jeg hen og kigger i skuffe nummer 1218 i mit kartotek for at se, hvad der står derinde.”
TeX bruger 1218 til at finde den rigtige skuffe, og dér finder den en lille note, som indeholder tre stykker information, hvis navne er dem, der bruges i TeX’s kildekode:
* **`eq_level:`** grupperingsniveauet, hvorpå denne post blev defineret (niveau 1 = globalt defineret). Vi så virkningerne af gruppering ovenfor: her i ækvivalenstabellen er det, at oplysningerne om grupperingsniveau gemmes;
* **`eq_type:`** kommandokoden for denne post;
* **`equiv:`** den aktuelle “værdi” af denne post—det kan være et simpelt heltal såsom kommandomodifikatoren nævnt ovenfor eller en pegepind til et område i hukommelsen; for eksempel hukommelsesplaceringen for samlingen af tokens, der repræsenterer en makrodefinition.
Så vores hashværdi 1218 (gemt i variablen `curcs`) er i praksis blevet brugt som *nøgle* til at få adgang til en skuffe, der indeholder den aktuelle betydning og værdi af den kommando, vi oprindeligt skrev ind som bogstavstrengen `\def`.
Inden for TeX-programmets kildekode `eq_type` for enhver kommando lagres ved hjælp af en variabel kaldet `curcmd` og værdien af `equiv` lagres i en variabel kaldet `curchr`.
### Hvad siger ækvivalenstabellen om def?
Som nævnt gemmes den hashværdi, der beregnes for enhver kommando, i en variabel kaldet `curcs`; derfor for `def` har vi `curcs=1218`. Når TeX slår op på placering 1218 i ækvivalenstabellen, finder det følgende oplysninger:
* `curcmd`=97. Dette er kommandokoden for `\def`;
* `curchr`=0. Dette er kommandomodifikatoren for `\def`.
`\def` er en primitiv (indbygget) TeX-kommando, og medmindre den er blevet omdefineret et sted, bør det tredje og sidste stykke information være `eq_level=1` hvilket indikerer, at betydningen af `\def` er defineret globalt og ikke begrænset til et lavere grupperingsniveau. Internt er værdien af `eq_level` knyttet til en kommando spiller en yderst vigtig rolle inden for TeX’s grupperingsmekanisme, men vi vil ikke gå nærmere ind på det.
Den følgende grafik opsummerer den forklaring, vi har gennemgået:
## TeX-tokens for kommandoer
Efter at have kæmpet os gennem forklaringerne ovenfor viser det sig, at selve beregningen af TeX-tokens for kontrolsekvenser er virkelig meget enkel. TeX bruger værdien af `curcs` (1218) fra hashfunktionen til at oprette et simpelt heltal, som det kalder et *token*token `curcs` er:
```c
curtok = 4095 + curcs
```
TeX gemmer værdien af det aktuelle token (senest beregnede) i en variabel kaldet `curtok`.
Så som konklusion er TeX-tokenet, der repræsenterer `\def` kommandoen er `4095 + 1218 = 5313`. Og det er det hele for TeX-tokens, der repræsenterer kommandosekvenser: de er blot et heltal, der beregnes ud fra en hashværdi plus 4095.
## TeX-tokens for tegn
Når TeX skal oprette et token, der repræsenterer et tegn, bruger det følgende lige så enkle beregning:
```c
curtok = 256*catcode + (ASCII value of character)
```
Bemærk, at der bruges lidt forskellige beregninger for Unicode-bevidste motorer såsom LuaTeX.
For eksempel er TeX-tokenet, der repræsenterer et mellemrumstegn med `\catcode` 10 og ASCII-værdi 32:
```c
256*10 + 32 = 2592
```
### Tokenlister, der indeholder tegn
Når du opretter en simpel tokenliste med for eksempel
```latex
\toks100={Hello}
```
vil TeX oprette følgende liste af tokens og gemme dem i hukommelsen til senere brug:
* H→ 256 × 11 + 72 = 2888
* e→ 256 × 11 + 101 = 2917
* l→ 256 × 11 +108 = 2924
* l→ 256 × 11 +108 = 2924
* o→256 × 11 + 111 = 2927
Dybt inde i TeX’s hukommelse vil tokenregister 100 give adgang til lagringsplaceringen for “Hello”, gemt som 5 tokenværdier: 2888, 2917, 2924, 2924, 2927. Bemærk, at disse tokens kombinerer hvert tegns ASCII-kode og værdien af dets `\catcode`på det tidspunkt, de bliver omdannet til tokens (tokeniseret). Når tegn først er blevet omdannet til tegntokens, er `\catcode` den værdi, der er knyttet til dem, permanent og lagret i tokenene til senere brug, når brugeren for eksempel skriver `\the\toks100`.
Som nævnt beregnes et tegntoken ud fra `256*catcode + (ASCII value)` hvorimod et kontrolsekvenstoken beregnes ud fra `4095 + curcs` hvor `curcs` er hashværdien af kontrolordet (tekststrengen af en brugerindtastet kommando), som TeX har registreret i inputtet. Det er værd at bemærke, at tegntokens altid er mindre end 4095. Derfor kan TeX let afgøre, om et bestemt token repræsenterer en kontrolsekvens (en kommando) eller et tegn, og derefter finde ud af, hvilken kontrolsekvens eller hvilket tegn og `\catcode` par der er kodet ind i det token.
---
# 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/53-what-is-a-tex-token.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.