> 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/nl/diepgaande-artikelen/53-what-is-a-tex-token.md).
# Wat is een "TeX-token"?
## Motivatie voor een reeks over TeX-tokens en gerelateerde concepten
De motivatie en methodologie die gebruikt zijn om een reeks artikelen over TeX-tokens en gerelateerde concepten te maken, worden in dit artikel besproken [Een nieuwe artikelenreeks: TeX-tokens en verwante concepten—maar waarom (en hoe)?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Zoals in dat artikel wordt opgemerkt, baseren we in deze reeks onze besprekingen en uitleg op inzichten die zijn verkregen via een aangepaste bouw van Knuths oorspronkelijke TeX-programma — waarbij we het gebruiken om een reeks artikelen te produceren die eenvoudige beschrijvingen en gemakkelijk te volgen uitleg van belangrijke TeX-concepten wil bieden.
## Inleiding: wat is ons doel?
In dit artikel ontdekken we precies wat een TeX-token is door het verwerkingspad te volgen van tekens in het invoerbestand tot de daadwerkelijke creatie van TeX-tokens. In de praktijk is het behoorlijk complex, dus hebben we het proces teruggebracht tot de kern, in een poging het gemakkelijk te volgen en te begrijpen te maken terwijl de technische nauwkeurigheid behouden blijft.
We beginnen met enkele belangrijke interne TeX-concepten: *primitieven*, *commando-codes* en *commandomodifiers*. Van daaruit gebruiken we een heel eenvoudig macrovoorbeeld om precies te zien hoe TeX het commando verwerkt `\def` en het resulterende token dat TeX maakt om dat commando voor te stellen.
We sluiten af met een korte blik op hoe TeX tokens maakt om tekens voor te stellen en hoe de `\catcode` daadwerkelijk permanent aan een tekentoken wordt gekoppeld — iets dat vaak in boeken over TeX wordt genoemd, maar hier zien we precies hoe dat wordt bereikt.
De volgende afbeelding laat de reis zien die we zullen samenvatten — van invoertekst naar TeX-tokens:
## Maar eerst: primitieven en commando-codes
Elke TeX-engine (Knuthiaanse TeX, pdfTeX, XeTeX, LuaTeX) begrijpt een aantal ingebouwde commando's: de zogenaamde *primitieven*—de fundamentele bouwsteen-commando's die de programmeerbaarheid van TeX ondersteunen. Ze worden “primitief” genoemd omdat ze, in tegenstelling tot door de gebruiker gedefinieerde macro's, niet uit andere commando's zijn opgebouwd en niet verder kunnen worden gereduceerd tot eenvoudigere instructies. Voor Knuths TeX zijn er ongeveer 320 primitieven — hoewel we moeten opmerken dat andere TeX-engines zoals pdfTeX, XeTeX en LuaTeX allemaal nieuwe commando's hebben toegevoegd aan Knuths oorspronkelijke programma en primitieven zullen bevatten die niet aanwezig zijn in Knuths TeX-software.
Intern kent TeX een numerieke *opdrachtcode* toe aan alle commando's — of het nu door de gebruiker gedefinieerde macro's of ingebouwde primitieven zijn. Deze commando-codes zijn niet toegankelijk voor de TeX-gebruiker; ze maken simpelweg deel uit van de interne mechaniek van TeX’ verwerking, maar het is nuttig om ze te kennen voor de latere bespreking van TeX-tokens.
Groepen commando's met gerelateerde functionaliteit delen dezelfde commando-code. Bijvoorbeeld de `\def`, `\gdef`, `\edef` en `\xdef` primitieven worden allemaal gebruikt om macro's te definiëren en delen de commando-code 97 (in Knuths TeX). Duidelijk creëren die 4 macrodefinitiecommando's elk macro's op een iets andere manier; daarom heeft TeX tijdens de verwerking een manier nodig om tussen hen te onderscheiden.
Een commando-code op zichzelf (zoals 97) kan niet vertellen welk macrocreatiecommando bedoeld wordt; dus, zoals je zou verwachten, krijgt elk TeX-commando een extra stuk informatie toegewezen dat zijn *commandomodifier* (zie onderstaande voorbeelden).
### Commandomodifiers: twee typen
Commandomodifiers vallen in twee categorieën die we “Type 1” en “Type 2” zullen noemen — TeX gebruikt deze terminologie niet, het is hier gewoon handig om dat wel te doen:
* **Type 1**: Eenvoudige gehele waarden die TeX, indien nodig, kan gebruiken om tussen commando's met dezelfde commando-code te onderscheiden.
* **Type 2**: Een gehele waarde die een numerieke locatie in het geheugen van TeX is en TeX vertelt waar het naartoe moet gaan om informatie voor dat commando op te zoeken. Dit geldt bijvoorbeeld voor door de gebruiker gedefinieerde commando's (macro's), waarbij de commandomodifier TeX vertelt waar de macrodefinitie in het geheugen is opgeslagen.
#### Type 1 commandomodifiers (een voorbeeld)
Zoals vermeld, hebben in Knuths TeX de vier primitieve commando's voor het definiëren van macro's: `\def`, `\gdef`, `\edef`, `\xdef` allemaal de commando-code 97: ze worden onderscheiden via hun commandomodifiers, die in de volgende tabel staan vermeld:
| Commando | Commando
code
| Commando
modifier
|
| -------- | ----------------------- | --------------------------- |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
Bij wijze van tweede voorbeeld besloot Knuth de commando's `\openout`, `\write`, `\closeout`, `\special`, `\immediate` en `\setlanguage` te implementeren als “uitbreidingen” van TeX, puur om te laten zien hoe je nieuwe primitieven aan TeX kunt toevoegen. In dit geval delen die commando's niet echt “vergelijkbare functionaliteit”, behalve dat Knuth besloot ze samen te groeperen om uit te leggen hoe je TeX kunt uitbreiden. Die 6 commando's worden geclassificeerd als “uitbreidingen” en gegroepeerd met de commando-code 59, maar elk heeft een passende commandomodifier om het van de anderen te onderscheiden:
| Commando | Commando
code
| Commando
modifier
|
| -------------- | ----------------------- | --------------------------- |
| `\openout` | 59 | 0 |
| `\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Type 2 commandomodifiers (een korte uitleg)
Hoewel alle commandomodifiers gehele getallen zijn, vereisen Type 2-modifiers wat extra uitleg. Deze commandomodifiers worden in TeX “pointers” genoemd omdat ze wijzen naar een locatie in het geheugen waar TeX aanvullende informatie voor dat commando kan vinden. Dit klinkt misschien wat vaag, maar de manier waarop TeX deze pointers gebruikt om informatie op te zoeken is erg divers en een volledige uitleg zou afleiden van het hoofddoel van dit artikel. Eén voorbeeld kan helpen: macro's. Wanneer een macrocommando wordt gedefinieerd, moet TeX de vervangingstekst ergens in het geheugen opslaan. Zoals we hieronder zullen zien, hebben door de gebruiker gedefinieerde macro's commando-codes tussen 111 en 114 met een commandomodifier die een pointer naar het geheugen is en TeX vertelt waar de vervangingstekst (de macrodefinitie) is opgeslagen.
### Commando-codes: uitbreidbaar en niet-uitbreidbaar
In Knuths broncode voor TeX variëren de commando-codes van 0 tot 120 — merk op dat sommige codes binnen dat bereik uitsluitend voor gespecialiseerde interne doeleinden zijn en niet zijn toegewezen aan commando's die toegankelijk zijn voor de gebruiker. Het is vermeldenswaard dat andere TeX-engines zoals pdfTeX, XeTeX en LuaTeX allemaal nieuwe commando's hebben toegevoegd aan Knuths oorspronkelijke set en meer primitieven, en overeenkomstige commando-codes, zullen bevatten; de hier geschetste principes zijn echter de kern van alle op TeX gebaseerde engines die zijn afgeleid van Knuths broncode.
De verzameling commando-codes is opgesplitst in twee hoofdsets:
* *niet-uitbreidbare commando's*: hebben commando-codes kleiner dan of gelijk aan 100;
* *uitbreidbare commando's*: hebben commando-codes groter dan 100, tot een maximale waarde van 120. Het bereik 101 tot 120 omvat door de gebruiker gedefinieerde macro's plus commando's zoals `\csname`, `\expandafter` en `\the`.
Niet-uitbreidbare commando's voeren doorgaans een toewijzing van een waarde aan een interne parameter uit of produceren rechtstreeks materiaal dat kan worden gezet. Uitbreidbare commando's “injecteren” doorgaans een stroom tokens in de huidige verwerkingsactiviteit van TeX of wijzigen de volgorde van de tokenverwerking.
Zoals hierboven vermeld, krijgen alle macro's (door de gebruiker gedefinieerde commando's) commando-codes tussen 111 en 114: de verschillende waarden weerspiegelen of de macro was gedefinieerd als `\long`, `\outer`, beide of geen van beide. Hier is een voorbeeld:
| Macrotype | Voorbeeld | Opmerking |
| --------------------- | ------------------------------ | --------------------------- |
| Niet-lang, niet-outer | `\def\ohyeah{....}` | `\ohyeah` commando-code=111 |
| Lang, niet-outer | `\long\def\ohyeah{....}` | `\ohyeah` commando-code=112 |
| Niet-lang, outer | `\outer\def\ohyeah{....}` | `\ohyeah` commando-code=113 |
| Lang, outer | `\long\outer\def\ohyeah{....}` | `\ohyeah` commando-code=114 |
Ter herinnering aan commandomodifiers: wanneer een macro wordt gedefinieerd, slaat TeX de definitie van de macro op in een bepaalde locatie in het geheugen: die locatie (een pointer) wordt de commandomodifier voor het macrocommando, dat wordt opgeslagen met een commando van 111 tot 114, afhankelijk van hoe het is gedefinieerd. De daadwerkelijke naam die aan een door de gebruiker gedefinieerde macro is toegewezen, doet er eigenlijk niet toe: na verwerking van de invoer krijgen ze allemaal een commando-code variërend van 111–114 en uiteindelijk worden alle commando's die TeX uit je invoer leest, of het nu primitieven of door de gebruiker gedefinieerde macro's zijn, uiteindelijk omgezet in een numerieke representatie die een *token*.
## De reis van invoertekst naar TeX-tokens
In dit gedeelte gebruiken we een heel eenvoudig macrovoorbeeld om precies te zien hoe TeX het commando verwerkt `\def` om een token te maken dat het `\def` commando voorstelt. De gedetailleerde verwerkingsactiviteit van TeX kan extreem complex zijn, dus gebruiken we geen macroparameters of scheidingstekens omdat dat de complexiteit zou vergroten en ons van onze reis zou afleiden.
Stel dat je TeX-invoerbestand de volgende regel bevat:
```latex
\def\ohyeah{Overleaf is cool!}
```
Terwijl TeX begint met het verwerken van deze invoerregel, controleert het de `\catcode` van elk teken en ziet het dat het eerste teken `\` (eerste teken van `\def`). Het detecteert (zoekt het op in een interne tabel) dat `\` heeft `\catcode` 0, wat betekent dat het het begin inleidt van een *controlesequentie*. Natuurlijk kun je elk teken opnieuw definiëren zodat het `\catcode` 0 heeft, maar we gaan ervan uit dat de conventionele definities van plain TeX of LaTeX worden gebruikt.
Strikt genomen heeft de term *controlesequentie* twee subcategorieën: *besturingswoord* en *besturingssymbool*:
* *besturingswoord*: een reeks tekens met `\catcode` letter (11);
* *besturingssymbool*: een enkel teken waarvan de `\catcode` is *niet* letter (11) is.
Op dit punt heeft het `\` teken zijn werk gedaan en is het nu klaar. Bij het detecteren van een escape-teken begint TeX vervolgens alle verdere tekens in de invoer te lezen met het oog op het detecteren van een besturingswoord of een controlesymbool.
Na het initiële `\`, detecteert TeX onmiddellijk het `d`: een teken waarvan de `\catcode` 11 is, wat TeX vertelt dat het de eerste letter van een *besturingswoord*heeft gevonden. Het blijft de volgende tekens scannen totdat het uiteindelijk een teken detecteert dat *doet niet* te `\catcode` letter (11) is. Alle volgende tekens (na de initiële `\`) met `\catcode` 11 (letter) worden geacht de naam van een besturingswoord te vormen: d.w\.z. de naam van een commando — misschien een macro of een primitief, maar TeX weet op dit moment nog niet welk type commando het is. Op dit punt is het simpelweg een tekenreeks.
Dus in ons voorbeeld scant TeX vrolijk verder, waarbij elk teken wordt gecontroleerd, totdat het bij de initiële `\` van `\ohyeah` komt die ook `\catcode` 0 heeft. TeX herkent dat het te ver heeft gescand en plaatst die `\` beleefd terug in de tekststroom, zodat het het volgende teken wordt dat wordt gezien tijdens verdere scanning van de tekst. Op dit punt heeft TeX een tekenreeks geïdentificeerd (`def`) waarvan het weet dat die de tekst vormt van een besturingswoord bestaande uit drie tekens, elk met `\catcode` 11 (`d`, `e` en `f`). Wat TeX nu moet doen is uitzoeken wat `def` betekent: wat moet het ermee doen? Zoals je misschien al geraden hebt, moet TeX de commando-code en commando-identificatie voor `def` vinden zodat het kan uitwerken wat het met dit commando moet doen.
## Er een hash van maken
Nadat het een besturingswoord (`def`) heeft gedetecteerd, is het eerste wat TeX doet de tekenreeks (`def` in ons voorbeeld) “omzetten” in een geheel getal door iets te gebruiken dat een hashfunctie wordt genoemd. We hoeven ons niet te veel zorgen te maken over de details; een schets volstaat. In wezen bekijkt TeX elk teken in het zojuist gedetecteerde besturingswoord en gebruikt het de ASCII-codewaarde (of Unicode-waarde voor XeTeX/LuaTeX) van elk teken om een getal te berekenen dat een hashwaarde wordt genoemd: het is gewoon een eenvoudig geheel getal.
Als onderdeel van dit hash-berekeningsproces controleert TeX ook of de tekenreeks in het nieuw gedetecteerde besturingswoord al bekend is. De leesbare tekst van alle commando's, of ze nu primitieven of door de gebruiker gedefinieerde macro's zijn, wordt opgeborgen in een intern opslaggebied dat de *stringpool*wordt genoemd. TeX moet dit doen omdat het mogelijk de voor mensen leesbare naam van een commando moet uitvoeren — bijvoorbeeld wanneer TeX een fout moet melden en de naam van het foutieve commando moet geven. Bijvoorbeeld, onze macro `\def\ohyeah{Overleaf is cool!}` definieert een nieuw commando genaamd `\ohyeah` en TeX zal (in een later stadium) niet alleen een hashwaarde voor `ohyeah` (*zonder* berekenen (de initiële `\` letter) maar ook de teksttekenreeks (leesbaar voor mensen) in opgeslagen vorm bewaren voor het geval het die nodig heeft voor foutmeldingen (of andere taken).
Als je meer detail wilt over TeX’ processen voor tekenreeksverwerking, heb ik hierover geschreven op mijn [persoonlijke blogsite](http://www.readytext.co.uk/?p=3590).
Het eindresultaat is dat de tekenreeks van tekens die het commando `def` voorstelt wordt omgezet in de numerieke waarde 1218 (dat is de werkelijke waarde die door TeX wordt berekend). Op dit punt maken de afzonderlijke tekens `d`, `e` en `f` geen deel meer uit van het hoofdverhaal — ze zijn uit de invoer gelezen en hebben hun werk gedaan: vanaf nu gaat het alleen nog om gehele getallen en *tokens*—we zullen zo meteen zien wat een token eigenlijk is! Intern noemt TeX deze hashwaardes de *huidige controlesequentie* maar in de broncode wordt die term afgekort tot een variabele genaamd `curcs`. De broncode van TeX zit vol met zeer korte, vaak nogal cryptische variabelenamen.
Maar wat doet TeX *eigenlijk* met deze pas berekende gehele waarde 1218? Hoe komt TeX erachter dat de oorspronkelijke tekenreeks `def`, nu voorgesteld door het geheel getal 1218, eigenlijk verwijst naar een instructie om een macro te definiëren? Het antwoord is dat TeX een soort interne “archiefkast” heeft waarin het de huidige betekenis en waarde van elk commando opslaat dat het op dat moment kent — of dat commando nu een door de gebruiker gedefinieerde macro of een ingebouwd primitief is. De reden dat TeX de moeite nam om `def` om te zetten in de hashwaarde 1218 (nu opgeslagen in de variabele genaamd `curcs`) is om die te gebruiken voor het opzoeken van de *betekenis* van `def`. TeX zal dit hash-berekeningsproces uiteraard herhalen voor alle besturingswoorden die het in de invoer detecteert — hoewel natuurlijk verschillende besturingswoorden verschillende gehele waarden opleveren uit de hashfunctie: dat is precies het idee.
TeX’ interne “archiefkast” heet de *equivalententabel* en is het onderwerp van de volgende sectie.
### De equivalententabel raadplegen
Om even samen te vatten, laten we zien wat we tot nu toe hebben geleerd:
* `\` introduceert het begin van een controlesequentie (ofwel een *besturingssymbool* of een *besturingswoord*).
* Als het eerste teken na de `\` heeft `\catcode` 11 (letter) is, dan is het het begin van een *besturingswoord*.
* Voor *besturingswoorden* TeX scant om te controleren op alle verdere invoertekens die `\catcode` 11 hebben en stopt met scannen zodra het het eerste teken vindt dat *niet* een `\catcode` van 11 heeft.
* De reeks invoertekens (na de `\`) die `\catcode` 11 hebben, worden beschouwd als een *besturingswoord* die de gebruiker heeft getypt: een commando dat TeX vraagt om “iets te doen”.
* Om het proces van “iets doen” te beginnen, zet TeX de tekenreeks in het besturingswoord om in een geheel getal. Dit doet het met behulp van een zogenaamde hashfunctie die een geheel getal als uitvoer geeft.
* Het geheel getal (berekende hashwaarde) wordt aangeduid als de *huidige controlesequentie*, maar TeX geeft het de kortere naam `curcs`.
* In ons voorbeeld wordt het besturingswoord `def` omgezet in de waarde 1218 — die wordt opgeslagen in een variabele genaamd `curcs`: i.e., `curcs=1218`.
TeX moet nu uitzoeken wat het zojuist gedetecteerde *huidige controlesequentie* eigenlijk betekent — wat doet TeX ermee?
#### Een opmerking over groepering: de noodzaak om informatie op te slaan en te herstellen
Hier nemen we even een kleine omweg om ons eraan te herinneren dat TeX de mogelijkheid heeft om informatie op te slaan en te herstellen: met andere woorden, het heeft een vorm van ingebouwd “geheugen”.
Iedereen die zelfs maar de eenvoudigste macro heeft geschreven, zou bekend moeten zijn met TeX’ groeperingsmechanisme — bijvoorbeeld het gebruik van `\def` om macro's binnen een groep te creëren. Tenzij je het `\global` voorvoegsel toevoegt aan `\def`-gemaakte macro's die binnen een groep zijn gedefinieerd, blijft de waarde of betekenis van die macro alleen bestaan binnen die groep (en de subgroepen daaronder): de definitie gaat verloren wanneer de groep eindigt. Als je bijvoorbeeld een eenvoudige macro binnen een groep definieert, zoals dit:
```latex
{\def\foo{Hello}}
```
en probeert `\foo` buiten de groep te gebruiken
```latex
{\def\foo{Hello}}% \foo gedefinieerd binnen een groep (let op: geen gebruik van \global)
\foo %<--- niet langer gedefinieerd, nu ongedefinieerd
```
dan krijgen we de gevreesde foutmelding: `Ongedefinieerde controlesequentie`. `\foo` heeft alleen betekenis binnen de groep (en haar subgroepen) waarin het werd gedefinieerd. Bovendien, wanneer je een macro binnen een groep opnieuw definieert, kan de nieuwe waarde verloren gaan wanneer de groep eindigt en de vorige betekenis (die buiten de groep bestond) wordt hersteld.
```latex
\def\foo{Goodbye}
\foo\par% Geeft Goodbye weer
{\def\foo{Hello}% Opnieuw gedefinieerd binnen een groep:
{Binnen groep van 2e niveau: \foo\par}}% Gebruikt binnen groep van 2e niveau: \foo geeft Hello weer
Buiten de groep wordt de oude waarde hersteld: \foo\par% Geeft Goodbye weer
```
Het doel van deze eenvoudige voorbeelden is te wijzen op het feit dat TeX een soort “opslagmechanisme” of “geheugen” heeft dat de “betekenis” van commando's opslaat en herstelt — en dat doet het natuurlijk ook. We hebben hier in de vorige sectie al op gezinspeeld: dat “opslagmechanisme” of die “archiefkast” is een grote interne tabel die de *equivalententabel*wordt genoemd. Daarin slaat TeX de huidige betekenis of waarden op van alle commando's die het op dat moment kent — de ingebouwde primitieven en de door de gebruiker gedefinieerde macro's.
### De equivalententabel: analoog beschouwd
Om de equivalententabel uit te leggen, gaan we via een analogie te werk. We blijven het idee gebruiken van een archiefkast met duizenden kleine laden, elk gelabeld met een uniek geheel getal. In dit stadium van de verwerking zegt TeX in feite:
“Oké, ik heb deze gehele waarde 1218 die ik net heb berekend en opgeslagen in een variabele genaamd `curcs`. Nu moet ik uitzoeken wat die betekent: om dat te doen ga ik lade nummer 1218 van mijn archiefkast bekijken om te zien wat daar staat.”
TeX gebruikt 1218 om de juiste lade te vinden en daar treft het een klein briefje aan met drie stukken informatie waarvan de namen die zijn die in TeX’ broncode worden gebruikt:
* **`eq_level:`** het groeperingsniveau waarop dit item werd gedefinieerd (niveau 1 = globaal gedefinieerd). We zagen hierboven al de effecten van groepering in actie: hier in de equivalententabel wordt die informatie over het groeperingsniveau opgeslagen;
* **`eq_type:`** de commando-code voor dit item;
* **`equiv:`** huidige “waarde” van dit item — dit kan een eenvoudig geheel getal zijn zoals de eerder genoemde commandomodifier, of een pointer naar een gebied in het geheugen; bijvoorbeeld de geheugenlocatie voor de verzameling tokens die een macrodefinitie voorstellen.
Dus onze hashwaarde van 1218 (opgeslagen in de variabele `curcs`) is in feite gebruikt als de *sleutel* om toegang te krijgen tot een lade met de huidige betekenis en waarde van het commando dat we oorspronkelijk als de tekenreeks letters `\def`.
Binnen de broncode van het TeX-programma wordt de `eq_type` voor elk commando opgeslagen met een variabele genaamd `curcmd` en de waarde van `equiv` wordt opgeslagen in een variabele genaamd `curchr`.
### Wat zegt de equivalententabel voor def?
Zoals vermeld, wordt de hashwaarde die voor elk commando wordt berekend opgeslagen in een variabele genaamd `curcs`; dus voor `def` we hebben `curcs=1218`. Bij het bekijken van locatie 1218 in de equivalententabel zal TeX de volgende informatie vinden:
* `curcmd`=97. Dit is de commando-code voor `\def`;
* `curchr`=0. Dit is de commandomodifier voor `\def`.
`\def` is een primitief (ingebouwd) TeX-commando en tenzij het ergens opnieuw is gedefinieerd, zou het derde en laatste stukje informatie moeten zijn `eq_level=1` waaruit blijkt dat de betekenis van `\def` globaal is gedefinieerd en niet beperkt is tot een lager groeperingsniveau. Intern speelt de waarde van `eq_level` die aan een commando is gekoppeld een uiterst belangrijke rol binnen TeX’ groeperingsmechanisme, maar we zullen hier niet verder op ingaan.
De volgende afbeelding vat de uitleg samen die we hebben doorlopen:
## TeX-tokens voor commando's
Na het doorworstelen van de bovenstaande uitleg blijkt de feitelijke berekening van TeX-tokens voor controlesequenties eigenlijk heel eenvoudig. TeX gebruikt de waarde van `curcs` (1218) uit de hashfunctie om een eenvoudig geheel getal te maken dat het een *token*noemt. De berekening om een token te genereren uit de waarde van `curcs` is:
```c
curtok = 4095 + curcs
```
TeX slaat de waarde van het huidige token (het meest recent berekende) op in een variabele genaamd `curtok`.
Dus, samenvattend is het TeX-token dat de `\def` commando is `4095 + 1218 = 5313`. En dat is alles voor TeX-tokens die commandosequenties voorstellen: ze zijn simpelweg een geheel getal dat wordt berekend uit een hashwaardetabel plus 4095.
## TeX-tokens voor tekens
Wanneer TeX een token moet maken dat een teken voorstelt, gebruikt het de volgende, even eenvoudige, berekening:
```c
curtok = 256*catcode + (ASCII-waarde van het teken)
```
Merk op dat voor Unicode-bewuste engines zoals LuaTeX iets andere berekeningen worden gebruikt.
Zo is bijvoorbeeld het TeX-token dat een spatiekarakter voorstelt met `\catcode` 10 en ASCII-waarde 32 is:
```c
256*10 + 32 = 2592
```
### Tokenlijsten die tekens bevatten
Wanneer je een eenvoudige tokenlijst maakt met bijvoorbeeld
```latex
\toks100={Hello}
```
zal TeX de volgende lijst van tokens maken en in het geheugen opslaan voor later gebruik:
* 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
Diep in het geheugen van TeX zal register 100 toegang geven tot de opslaglocatie van “Hello”, opgeslagen als 5 tokenwaarden: 2888, 2917, 2924, 2924, 2927. Merk op dat deze tokens de ASCII-code van elk teken combineren met de waarde van zijn `\catcode`op dat punt worden ze omgezet in tokens (getokeniseerd). Zodra tekens zijn omgezet in tekentokens, is de `\catcode` waarde die eraan gekoppeld is permanent en wordt die opgeslagen binnen de tokens voor later gebruik wanneer de gebruiker bijvoorbeeld zegt, `\the\toks100`.
Zoals vermeld wordt een tekentoken berekend uit `256*catcode + (ASCII-waarde)` terwijl een controlesequentietoken wordt berekend uit `4095 + curcs` waar `curcs` is de hashwaarde van het besturingswoord (tekststring van een door de gebruiker getypt commando) dat door TeX in de invoer is gedetecteerd. Het is vermeldenswaard dat tekentokens altijd kleiner zijn dan 4095. Daarom kan TeX gemakkelijk bepalen of een bepaald token een controlesequentie (een commando) of een teken voorstelt en vervolgens uitzoeken welke controlesequentie of welk teken en `\catcode` paar erin gecodeerd is in dat 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/nl/diepgaande-artikelen/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.