> 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/meer-onderwerpen/21-how-tex-macros-actually-work-part-3.md).
# Hoe TeX-macro's echt werken: Deel 3
[Deel 1](/latex/nl/meer-onderwerpen/19-how-tex-macros-actually-work-part-1.md) [Deel 2](/latex/nl/meer-onderwerpen/20-how-tex-macros-actually-work-part-2.md) [Deel 3](/latex/nl/meer-onderwerpen/21-how-tex-macros-actually-work-part-3.md) [Deel 4](/latex/nl/meer-onderwerpen/22-how-tex-macros-actually-work-part-4.md) [Deel 5](/latex/nl/meer-onderwerpen/23-how-tex-macros-actually-work-part-5.md) [Deel 6](/latex/nl/meer-onderwerpen/24-how-tex-macros-actually-work-part-6.md)
## Tijd om even te pauzeren!
Voordat we verdergaan met het volgende deel van dit verhaal, moeten we even samenvatten: ons herinneren waar we naartoe gaan en onze gedachten ordenen om ervoor te zorgen dat alle kernideeën op hun plaats staan. Nog even ter herinnering: ons uitgewerkte voorbeeld is gebaseerd op de aanname dat TeX een regel tekst heeft gelezen met `Hello World \jobname` en dat TeX dit opmaakt om een alinea te bouwen.
### Het uiteindelijke doel
Ons doel is een beter (dieper) begrip te ontwikkelen van de aard van TeX-macro's en hoe ze werken. Om daar te komen, moeten we echter eerst begrijpen hoe TeX een invoerbestand leest en de tekens daarin verwerkt. Hier is een samenvatting van de onderwerpen die tot nu toe aan bod zijn gekomen.
* TeX leest (scant) elk teken in je invoer en heeft voor elk teken twee stukjes informatie:
* **tekencode**: een geheel getal dat wordt gebruikt om dat teken te identificeren, bijvoorbeeld wanneer het is opgeslagen in een .tex-invoerbestand;
* **categoriecode**: nog een geheel getal, intern voor TeX, dat het gebruikt om betekenis toe te kennen aan elk teken dat uit de invoer wordt gelezen.
* Zodra een teken door TeX is ingelezen, wordt de categoriecode van elk teken *permanent* gekoppeld aan dat afzonderlijke teken via het aanmaken van een karaktertoken:
* TeX gebruikt een eenvoudige formule om een tekencode en de bijbehorende categoriecode samen te voegen tot een geheel getal dat een karaktertoken heet.
* Je kunt de betekenis veranderen van elk teken dat TeX heeft *nog niet ingelezen* door een andere categoriecode toe te kennen aan elk teken waarvan je het gedrag wilt veranderen—oftewel, de manier waarop TeX dat teken behandelt aan te passen.
* Het opnieuw definiëren (her-mappen) van categoriecodes gebeurt met TeX's primitieve `\catcode` commando.
* Wanneer TeX een categoriecode 0 ziet, schakelt het over naar een speciale scanmodus en begint het naar de naam van een commando te zoeken: ofwel een (mogelijk) meerletterig *besturingswoord* of een enkeltekens *besturingssymbool*.
Tot nu toe hebben we gekeken naar het invoerscantproces van TeX terwijl het afzonderlijke tekens identificeert en de categoriecode van elk teken gebruikt om uit te zoeken wat het vervolgens moet doen. Sommige tekens zijn gewoon normale tekstonderdelen voor opmaak (bijv. categoriecode 11), maar we hebben ook spatiekarakters gezien (categoriecode 10) en escape-tekens (categoriecode 0). Er zijn nog andere categoriecodes waar we omwille van de beknoptheid niet naar hebben gekeken—zoals categoriecode 1 (“groep starten”, bijvoorbeeld, `{`) categoriecode 2 (“groep beëindigen”, bijvoorbeeld, `}`) en andere. Elke categoriecode heeft zijn eigen rol in TeX's invoerscannen en de daaropvolgende verwerking door de softwareprocessen/-algoritmen binnen TeX.
### Tokens: een snelle herhaling
Het concept van “tokens” staat centraal in de manier waarop TeX werkt: je zult “tokens” genoemd of aangehaald zien worden in TeX-gerelateerde boeken, artikelen en online gemeenschappen, dus het is de moeite waard dit onderwerp kort te herhalen—meer details vind je in een eerder gepubliceerd artikel [Wat is een "TeX-token"?](/latex/nl/diepgaande-artikelen/53-what-is-a-tex-token.md)
We hebben al gezien dat TeX invoertekens omzet in tokens door de tekencode en categoriecode samen te voegen tot één samengesteld geheel getal. TeX doet iets soortgelijks voor commando's: met behulp van de naam van het commando berekent het een geheel getal dat een *commando-token* (we zullen dit later uitgebreider onderzoeken). Als leidraad kun je tokens zien als TeX's manier om items die het uit de invoer heeft gelezen “te verpakken”, zodat ze klaar zijn voor doorgifte naar de volgende fase van TeX's verwerking. Dat alle items (tekens of commando's) netjes in één numerieke representatie worden verpakt, maakt het eenvoudiger om ze verderop in de keten te verwerken. Wanneer TeX bijvoorbeeld iets van je invoer wil opslaan om later te gebruiken, zoals een macrodefinitie, hoeft TeX alleen je macrodefinitie, hoe complex ook, op te slaan als een reeks gehele getallen, waarbij elk geheel getal een token is dat een teken of een commando vertegenwoordigt dat deel uitmaakt van (deel uitmaakt van) de definitie van je macro.
## En wat nu?
In het laatste deel van Deel 2 zagen we hoe een escape-teken (categoriecode 0) TeX in een speciale verwerkingsmodus zet waarin het op zoek gaat naar de naam van een commando. In ons voorbeeld detecteerde TeX de tekenreeks `jobname` en we sloten Deel 2 af op het punt waarop TeX iets zou gaan “doen” met die tekenreeks van tekens (de naam van een commando). In dit deel zullen we in detail bekijken wat TeX vervolgens doet.
Zodra TeX heeft vastgesteld dat een bepaalde reeks tekens in je invoerbestand de naam van een commando vormen (hier, `jobname`) kan TeX, afhankelijk van wat het aan het doen is, dat commando moeten uitvoeren. We zeggen “kan moeten”, omdat er momenten zijn waarop TeX niet meteen probeert een commando uit te voeren: bijvoorbeeld wanneer het een macro definieert (TeX bouwt tokenlijsten)—onderwerpen die we later zullen bespreken. We blijven echter ons voorbeeld volgen waarin TeX een alinea opmaakt en *zal*, in deze situatie, moeten uitvoeren `\jobname`.
### Van een tekenreeks naar het uitvoeren van een commando: hoe?
Laten we eerst Figuur 5b uit Deel 2 opnieuw bekijken, waarin TeX heeft vastgesteld dat een bepaalde tekenreeks in de invoer de naam van een commando vormt: `jobname`. Figuur 5b geeft aan dat TeX “interne tabellen moet controleren...”. Wat betekent dat *eigenlijk*?
Een andere, meer gedetailleerde beschrijving van hoe TeX “interne tabellen controleert” om de overgang te maken van een tekenreeks (bijv. `jobname`) naar het exact uitzoeken wat het commando is en wat het betekent, is te vinden in een eerder artikel [Wat is een "TeX-token"?](/latex/nl/diepgaande-artikelen/53-what-is-a-tex-token.md) Hier zullen we de kernideeën samenvatten en proberen onnodige herhaling te vermijden.
Laten we beginnen met een analogie. Stel dat je een boek leest en een onbekend woord tegenkomt: wat doe je dan? Tegenwoordig is het vrijwel zeker “Google raadplegen”, maar laten we aannemen dat je een oudere methode prefereert: je pakt een woordenboek dat woorden opsomt en hun betekenis(sen) geeft. TeX heeft een vergelijkbaar mechanisme: een intern “woordenboek” dat alle commando's bevat die TeX op dat moment kent—en de “betekenis” van die commando's. Met “betekenis” bedoelen we: wat voor soort commando is het? Wat doet het, plus alle andere informatie die TeX mogelijk nodig heeft om dat commando uit te voeren. Merk ook op dat de term “commando” alle TeX-/LaTeX-macro's omvat die zijn geschreven door gebruikers/TeX-programmeurs en de [honderden ingebouwde primitieve commando's](/latex/nl/meer-onderwerpen/46-tex-primitives-listed-by-tex-engine.md).
Voortbordurend op onze woordenboekanalogie. Wanneer wij als menselijke lezer de betekenis van een woord moeten opzoeken, zoeken we in het woordenboek via de alfabetische lijst van woorden die het woordenboek biedt—maar zo werkt TeX natuurlijk niet helemaal. Terug naar ons oorspronkelijke `jobname` voorbeeld: hoe vindt TeX, binnen zijn “woordenboek”, de “betekenis” van `jobname`—en wat levert die “betekenis” TeX eigenlijk op?
In plaats van een interne “alfabetische lijst” van alle commando's die TeX kent, doet het iets anders. TeX zet de volledige reeks tekens—zoals die in de naam van een commando voorkomt—om in één geheel getal, dat zal worden gebruikt om dat commando te identificeren (voor te stellen). Intern houdt TeX een groot “woordenboek” bij van alle bekende commando's, waarin het de *gehele getallen* berekend uit commandonamen—merk op dat dat woordenboek de eigenlijke commandonamen zelf niet opslaat als reeksen letters (genoemd *strings*). TeX gebruikt dat woordenboek voor al zijn ingebouwde commando's (primitieven) *en* het zal het gebruiken om details op te slaan van elke macro (commando) die door gebruikers wordt gemaakt: de naam van je macro wordt omgezet in een geheel getal en dat getal wordt “geregistreerd” in TeX's woordenboek.
Elke keer dat TeX een commando in je invoer detecteert en iets over dat commando moet weten, zet het de reeks tekens in de commandonaam om in een “equivalent” geheel getal en gebruikt dat geheel getal om het commando op te zoeken in zijn “grote woordenboek”. Voor de programmeurs onder jullie is het misschien interessant om te weten dat TeX een vorm van [hashfunctie](https://en.wikipedia.org/wiki/Hash_function) gebruikt om die omzetting uit te voeren.
### Figuur 6: Van tekens naar commando-betekenis
De volgende afbeelding laat de reis zien die een commando aflegt terwijl TeX de tekenreeks omzet in een equivalent geheel getal, dat het noemt **curcs**, en gebruikt dat geheel getal om de betekenis van het commando op te zoeken in TeX's “grote woordenboek”. Het resultaat van die opzoeking is twee stukjes informatie: twee gehele getallen, genaamd **curcmd** en **curchr**, die TeX kan gebruiken om exact uit te zoeken wat het commando doet en hoe het vervolgens moet worden uitgevoerd.
Intern houdt TeX een variabele bij die heet **curcs** (**cur**rent **c**ontrol **s**equence) die wordt gebruikt om het gehele-getalwaarde van het commando waarop TeX op dat moment werkt op te slaan—oftewel, **curcs** slaat het geheel getal op dat is berekend uit de naam van het commando. Dat is nog niet het hele verhaal, want er is nog één detail: als TeX net een teken heeft gelezen/verwerkt en niet een commando, dan zet het **curcs** op de waarde 0, om te onthouden dat het laatste ingelezen item een teken was en geen commando.
### Wat commando's voor TeX betekenen
Als we kijken naar de set van [ingebouwde commando's die door TeX-engines worden geleverd](/latex/nl/meer-onderwerpen/46-tex-primitives-listed-by-tex-engine.md) zien we dat sommige van die commando's nauw verwant zijn: ze voeren vergelijkbare taken uit; er zijn bijvoorbeeld 4 primitieve commando's die alle TeX-engines gebruiken om macro's te definiëren (aan te maken): `\def`, `\gdef`, `\edef`, `\xdef`. Die 4 commando's definiëren allemaal macro's, maar natuurlijk doet elk dat net iets anders. Als we dit vanuit programmeerperspectief bekijken: we hebben hier 4 commando's voor macrodefinitie die in grote lijnen hetzelfde doen, maar we moeten tussen hen kiezen om rekening te houden met hun individuele gedrag.
Om dit aan te pakken kent TeX twee waarden toe aan elk commando, en die twee waarden zijn wat TeX begrijpt als de “betekenis” van een commando (zijn rol/wat het doet)—die twee waarden zijn intern aan TeX, diep in de software, en maken deel uit van het “innerlijke mechanisme” dat niet toegankelijk is voor gebruikers. Elk TeX-commando, of het nu een ingebouwd primitief commando of een door de gebruiker gedefinieerd commando is, krijgt twee waarden toegewezen die, voor TeX, zijn gedrag definiëren/classificeren—wat het voor TeX betekent. Wanneer TeX zijn “grote woordenboek” gebruikt om een commando op te zoeken, vindt het die twee cruciale stukjes informatie:
* **opdrachtcode**: een soort “algemene classificatie” die aangeeft van welk “type” commando het is—zoals een commando voor “macrodefinitie” (een van `\def`, `\gdef`, `\edef`, `\xdef`); een commando voor “het maken van een box” (een van `\hbox`, `\vbox` of `\vcenter`) enzovoort voor de honderden commando's die TeX-engines ondersteunen. Macro's (door de gebruiker gedefinieerde commando's) krijgen ook een commando-code toegewezen.
* **commandomodifier**: Dit is aanvullende informatie die TeX specifieke informatie over een commando geeft. Macro's (door de gebruiker gedefinieerde commando's) krijgen ook een commandomodifier toegewezen—hoewel bij macro's de commandomodifier een iets andere rol speelt dan bij primitieven (voor macro's geeft de commandomodifier aan waar de macrodefinitie in het geheugen is opgeslagen).
Samen genomen identificeren de commando-code en commandomodifier elk commando uniek. Hier zijn de commando-codes en commandomodifiers voor de macrodefinitie-commando's zoals gebruikt door Knuths oorspronkelijke TeX-software—merk op dat andere TeX-engines andere waarden kunnen gebruiken, maar ze volgen precies hetzelfde principe:
| | | |
| ------------ | --------------------------------------------------------- | ------------------------------------------------------------- |
| **Commando** | Commando
code
| Commando
modifier
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Samenvatting: orde scheppen in al deze variabelen/waarden
Op dit punt worden we overspoeld met veel informatie over waarden, variabelen, commando-waarden en allerlei details—dat kan al snel verwarrend worden, dus laten we op een rij zetten wat we weten. Wanneer TeX iets uit je invoer leest, is het ofwel een teken ofwel een commando. Elke keer dat TeX iets uit de invoer leest, moet het informatie opslaan over wat het zojuist heeft gelezen (gescand):
* Voor **tekens**: het moet de tekencode en de categoriecode vastleggen. Het moet ook de tokenwaarde aanmaken en opslaan die TeX met behulp van die waarden berekent.
* Voor **commando's**: TeX moet het numerieke equivalent weten, **curcs**, dat het heeft berekend uit de commandonaam. Het moet mogelijk ook de “betekenis” opslaan die het heeft opgehaald door het commando op te zoeken in TeX's “woordenboek”: de commando-code en de commandomodifier. Daarbovenop moet TeX ook een tokenwaarde berekenen die dit commando vertegenwoordigt.
Ja, het is verwarrend: er zweven allerlei variabelen en tokenideeën rond, dus laten we proberen hier orde in te scheppen.
Intern gebruikt TeX vier globale variabelen om informatie op te slaan over het laatst ingelezen item dat TeX heeft gelezen (of waar het momenteel aan “werkt”)—we zullen die variabelen niet in detail bespreken, maar het weten van hun bestaan helpt om wat meer achtergrond te geven en te begrijpen wat er echt gebeurt:
* **curcmd**: (current command) een variabele met een geheel getal. Het wordt gebruikt om de *huidige commando* waarde van het commando dat wordt verwerkt *of* het slaat de de huidige *categoriecode* van het teken dat wordt verwerkt op;
* **curchr**: (current character) een variabele met een geheel getal, maar wat het opslaat hangt af van wat TeX zojuist uit zijn invoer heeft gelezen:
* **teken**: Als het meest recent ingelezen item een teken is, **curchr** slaat het de huidige *tekencode*.
* **commando**: Als het meest recent ingelezen item een commando is, **curchr** slaat het de *commandomodifier*: aanvullende informatie die TeX gebruikt om te ondersteunen/verduidelijken **curcmd**—omdat, zoals we hierboven zagen, sommige commando's dezelfde waarde delen van **curcmd**
* **curcs**: (current control sequence) een variabele met een geheel getal die de waarde opslaat die is berekend uit de tekenreeks in een commandonaam. **curcs** = 0 als het laatst gelezen item een afzonderlijk teken was en niet de naam van een control sequence (een commandonaam);
* **curtok**: (current token) een variabele met een geheel getal die de waarde van de huidige token bevat—dat is ofwel een commandotoken of een karaktertoken.
Hier staat bovenstaande informatie in tabelvorm:
| | | |
| ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| **Globale variabele die binnen TeX wordt gebruikt:** | **Wanneer TeX een teken scant:** | **Wanneer TeX een commando scant:** |
| **curcmd** | Slaat de categoriecode van het huidige teken op | Slaat de *opdrachtcode*—die het “type” van het huidige commando identificeert |
| **curchr** | Slaat de tekencode van het huidige teken op | Slaat aanvullende gegevens op (genaamd de *commandomodifier*) die aanvullende informatie over het huidige commando geeft |
| **curcs** | 0 | Een positief geheel getal ongelijk aan nul dat wordt berekend (via een hashfunctie) met behulp van de tekenreeks in de commandonaam. Het wordt gebruikt om toegang te krijgen tot TeX's “woordenboek” om de huidige betekenis van een commando op te zoeken—om zijn commando-code en commandomodifier op te halen. |
| **curtok** | Voor 8-bits TeX-engines wordt een *tekentoken* tokenwaarde $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ waar $$\text{curcmd}$$ wordt berekend met de formule: $$\text{curchr}$$ is de categoriecode van het teken en | Voor 8-bits TeX-engines wordt een *commando-token* tokenwaarde $$\text{curtok}=4095 + \text{curcs}$$ |
### Verdere opmerkingen over de huidige token
Voor tekens wordt de maximaal mogelijke tokenwaarde verkregen met de grootste categoriecode (15) en de grootste tekencode die, voor 8-bits TeX-engines, 255 is. In theorie (voor 8-bits TeX-engines) is de maximale karaktertokenwaarde, $$\text{curtok}\_{\text{max}}$$, namelijk:
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
We merken “in theorie” op omdat categoriecode 15 wordt gebruikt om een “ongeldig teken” weer te geven, wat TeX een fout laat genereren: een ongeldig teken komt nooit door TeX's invoerscantproces heen en wordt dus nooit een karaktertoken.
Voor commando's wordt de huidige token ($$\text{curtok}$$) berekend uit $$\text{curtok}=4095 + \text{curcs}$$ maar voor commando's $$\text{curcs}$$ is *altijd* niet nul, zodat TeX gemakkelijk kan bepalen wat een token voorstelt:
* Als $$\text{curtok} > 4095$$ dan is het een commandotoken;
* Als $$\text{curtok} < 4095$$ is het een karaktertoken.
Feitelijk gebruikt TeX tokens, een eenvoudige gehele-getalwaarde, om alle informatie die het moet weten over een item dat uit de invoer is gelezen te “verpakken”.
## Deel 4
In Deel 4 onderzoeken we een reeks voorbeeldmacro's om de rol en het doel van een macro's `` sectie te laten fungeren als een “tokensjabloon” dat kan worden opgebouwd met behulp van scheidingstoken.
[Deel 1](/latex/nl/meer-onderwerpen/19-how-tex-macros-actually-work-part-1.md) [Deel 2](/latex/nl/meer-onderwerpen/20-how-tex-macros-actually-work-part-2.md) [Deel 3](/latex/nl/meer-onderwerpen/21-how-tex-macros-actually-work-part-3.md) [Deel 4](/latex/nl/meer-onderwerpen/22-how-tex-macros-actually-work-part-4.md) [Deel 5](/latex/nl/meer-onderwerpen/23-how-tex-macros-actually-work-part-5.md) [Deel 6](/latex/nl/meer-onderwerpen/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/nl/meer-onderwerpen/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.