> 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/fr/articles-approfondis/53-what-is-a-tex-token.md).
# Qu’est-ce qu’un « jeton TeX » ?
## Motivation pour une série sur les jetons TeX et les concepts associés
Dans cet article, on discute de la motivation et de la méthodologie utilisées pour produire une série d’articles sur les jetons TeX et les concepts associés [Une nouvelle série d’articles : les jetons TeX et les concepts associés — mais pourquoi (et comment) ?](https://www.overleaf.com/blog/521-a-new-series-of-articles-tex-tokens-and-related-concepts-but-why-and-how) Comme indiqué dans cet article, tout au long de cette série nous fondons nos discussions et nos explications sur les enseignements tirés d’une compilation personnalisée du programme TeX original de Knuth — en l’utilisant pour produire une série d’articles visant à fournir des descriptions simples et des explications faciles à suivre des concepts clés de TeX.
## Introduction : quel est notre objectif ?
Dans cet article, nous découvrons exactement ce qu’est un jeton TeX en retraçant le parcours de traitement, depuis les caractères du fichier d’entrée jusqu’à la création effective des jetons TeX. En pratique, c’est assez complexe, nous avons donc réduit le processus à ses éléments essentiels, en nous efforçant de le rendre facile à suivre et à comprendre tout en préservant la précision technique.
Nous commençons par présenter quelques concepts internes importants de TeX : *primitives*, *codes de commande* et *modificateurs de commande*. À partir de là, nous utilisons un exemple de macro très simple pour voir exactement comment TeX traite la commande `\def` et le jeton résultant que TeX crée pour représenter cette commande.
Nous terminerons par un bref aperçu de la manière dont TeX crée des jetons pour représenter les caractères et dont le code de catégorie d’un caractère `\catcode` est bien attaché de façon permanente à un jeton de caractère — une chose souvent mentionnée dans les livres sur TeX, mais ici nous voyons exactement comment cela est réalisé.
Le graphique suivant montre le parcours que nous allons résumer — du texte d’entrée aux jetons TeX :
## Mais d’abord : primitives et codes de commande
Chaque moteur TeX (Knuthian TeX, pdfTeX, XeTeX, LuaTeX) comprend un certain nombre de commandes intégrées : les fameuses *primitives*—les commandes fondamentales qui constituent les briques de base sur lesquelles repose la programmabilité de TeX. On les appelle « primitives » parce que, contrairement aux macros définies par l’utilisateur, elles ne sont pas construites à partir d’autres commandes et ne peuvent pas être réduites davantage en instructions plus simples. Pour le TeX de Knuth, il existe environ 320 primitives — bien que nous devions noter que d’autres moteurs TeX comme pdfTeX, XeTeX et LuaTeX ont tous ajouté de nouvelles commandes au programme original de Knuth et contiennent des primitives qui ne sont pas présentes dans le logiciel TeX de Knuth.
En interne, TeX attribue un code numérique *code de commande* à toutes les commandes — qu’il s’agisse de macros définies par l’utilisateur ou de primitives intégrées. Ces codes de commande ne sont pas accessibles à l’utilisateur de TeX ; ils font simplement partie de la mécanique interne du traitement de TeX, mais il est utile de les connaître pour la discussion ultérieure des jetons TeX.
Les groupes de commandes ayant des fonctionnalités liées partagent le même code de commande. Par exemple, les `\def`, `\gdef`, `\edef` et `\xdef` primitives de définition de macros utilisent toutes le code de commande 97 (dans le TeX de Knuth). De toute évidence, ces 4 commandes de définition de macros créent chacune des macros d’une manière légèrement différente ; par conséquent, lors du traitement, TeX a besoin d’un moyen de les distinguer.
Un code de commande pris isolément (comme 97) ne peut pas vous dire quelle commande de création de macro est concernée ; aussi, comme on peut s’y attendre, chaque commande TeX se voit attribuer une information supplémentaire appelée son *modificateur de commande* modificateur de commande (voir les exemples ci-dessous).
### Modificateurs de commande : deux types
Les modificateurs de commande se répartissent en deux catégories que nous appellerons « type 1 » et « type 2 » — TeX n’emploie pas cette terminologie, c’est simplement pratique de le faire ici :
* **Type 1**: Des valeurs entières simples que TeX peut, si nécessaire, utiliser pour distinguer des commandes partageant le même code de commande.
* **Type 2**: Une valeur entière qui correspond à un emplacement numérique dans la mémoire de TeX, indiquant à TeX où il doit aller pour rechercher les informations relatives à cette commande. Par exemple, cela s’applique aux commandes définies par l’utilisateur (macros), où le modificateur de commande indique à TeX où la définition de la macro est stockée en mémoire.
#### Modificateurs de commande de type 1 (un exemple)
Comme indiqué, dans le TeX de Knuth, les quatre commandes primitives de définition de macros : `\def`, `\gdef`, `\edef`, `\xdef` partagent toutes le code de commande 97 : elles sont différenciées par leurs modificateurs de commande, qui sont listés dans le tableau suivant :
| Commande | Code de
commande
| Modificateur de
commande
|
| -------- | -------------------------- | ---------------------------------- |
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
À titre de second exemple, Knuth a décidé d’implémenter les commandes `\openout`, `\write`, `\closeout`, `\special`, `\immediate` et `\setlanguage` comme des « extensions » à TeX, uniquement pour montrer comment on peut ajouter de nouvelles primitives à TeX. Dans ce cas, ces commandes ne partagent pas vraiment une « fonctionnalité similaire », si ce n’est que Knuth a décidé de les regrouper afin d’expliquer comment étendre TeX. Ces 6 commandes sont classées comme des « extensions » et regroupées avec la valeur de code de commande 59, mais chacune possède un modificateur de commande approprié pour la distinguer des autres :
| Commande | Code de
commande
| Modificateur de
commande
|
| -------------- | -------------------------- | ---------------------------------- |
| `\openout` | 59 | 0 |
| `\write` | 59 | 1 |
| `\closeout` | 59 | 2 |
| `\special` | 59 | 3 |
| `\immediate` | 59 | 4 |
| `\setlanguage` | 59 | 5 |
#### Modificateurs de commande de type 2 (brève explication)
Bien que tous les modificateurs de commande soient des entiers, les modificateurs de type 2 demandent un peu plus d’explications. Dans TeX, on appelle ces modificateurs de commande des « pointeurs » parce qu’ils pointent vers un emplacement en mémoire où TeX peut trouver des informations supplémentaires pour cette commande. Cela peut sembler un peu vague, mais la manière dont TeX utilise ces pointeurs pour rechercher des informations est très variée et une explication plus complète détournerait de l’objectif principal de cet article. Un exemple peut aider : les macros. Lorsqu’une commande de macro est définie, TeX devra stocker le texte de remplacement quelque part en mémoire. Comme nous le verrons ci-dessous, les macros définies par l’utilisateur ont des codes de commande compris entre 111 et 114 avec un modificateur de commande qui est un pointeur vers la mémoire indiquant à TeX où est stocké son texte de remplacement (la définition de la macro).
### Codes de commande : extensibles et non extensibles
Dans le code source de Knuth pour TeX, les codes de commande vont de 0 à 120 — notez que certains codes dans cet intervalle sont purement destinés à un usage interne spécialisé et ne sont pas attribués à des commandes accessibles à l’utilisateur. Il convient de noter que d’autres moteurs TeX tels que pdfTeX, XeTeX et LuaTeX ont tous ajouté de nouvelles commandes à l’ensemble original de Knuth et contiendront davantage de primitives, ainsi que des codes de commande correspondants ; cependant, les principes exposés ici sont au cœur de tous les moteurs basés sur TeX dérivés du code source de Knuth.
L’ensemble des codes de commande se divise en deux grands groupes :
* *commandes non extensibles*: ont des codes de commande inférieurs ou égaux à 100 ;
* *commandes extensibles*: ont des codes de commande supérieurs à 100, jusqu’à une valeur maximale de 120. L’intervalle 101 à 120 comprend les macros définies par l’utilisateur ainsi que des commandes telles que `\csname`, `\expandafter` et `\the`.
Les commandes non extensibles effectuent généralement l’affectation d’une valeur à un paramètre interne ou produisent directement du matériau pouvant être composé. Les commandes extensibles « injectent » généralement un flux de jetons dans l’activité de traitement en cours de TeX ou modifient l’ordre de traitement des jetons.
Comme indiqué ci-dessus, toutes les macros (commandes définies par l’utilisateur) se voient attribuer des codes de commande compris entre 111 et 114 : les différentes valeurs reflètent le fait que la macro ait été définie comme `\long`, `\outer`, les deux, ou aucun. Voici un exemple :
| Type de macro | Exemple | Commentaire |
| --------------------- | ------------------------------ | ------------------------------ |
| Non long, non externe | `\def\ohyeah{....}` | `\ohyeah` code de commande=111 |
| Long, non externe | `\long\def\ohyeah{....}` | `\ohyeah` code de commande=112 |
| Non long, externe | `\outer\def\ohyeah{....}` | `\ohyeah` code de commande=113 |
| Long externe | `\long\outer\def\ohyeah{....}` | `\ohyeah` code de commande=114 |
Pour rappeler les modificateurs de commande, lorsqu’une macro est définie TeX stocke la définition de la macro dans un emplacement de mémoire : cet emplacement (un pointeur) devient le modificateur de commande pour la commande de macro, qui sera stockée avec un code de commande de 111 à 114 selon la façon dont elle a été définie. Le nom réel attribué à une macro définie par l’utilisateur n’a pas vraiment d’importance : après traitement de l’entrée, elles recevront toutes un code de commande variant de 111 à 114 et, au final, toutes les commandes que TeX lit dans votre entrée, qu’il s’agisse de primitives ou de macros définies par l’utilisateur, sont finalement converties en une représentation numérique appelée un *le jeton*.
## Le parcours du texte d’entrée aux jetons TeX
Dans cette section, nous allons utiliser un exemple de macro très simple pour voir exactement comment TeX traite la commande `\def` pour créer un jeton qui représente la `\def` commande. L’activité de traitement détaillée de TeX peut être extrêmement complexe, nous n’utilisons donc pas de paramètres de macro ni de délimiteurs, car cela ajouterait de la complexité et détournerait l’attention de notre parcours.
Supposons que votre fichier d’entrée TeX contienne la ligne suivante :
```latex
\def\ohyeah{Overleaf is cool!}
```
Lorsque TeX commence à traiter cette ligne d’entrée, il vérifie le `\catcode` de chaque caractère et voit que le premier caractère est `\` (premier caractère de `\def`). Il détecte (le cherche dans une table interne) que `\` a `\catcode` 0, ce qui signifie qu’il introduit le début d’une *séquence de contrôle*. Bien sûr, vous pouvez redéfinir n’importe quel caractère pour qu’il ait `\catcode` 0, mais nous supposerons que les définitions conventionnelles de plain TeX ou de LaTeX sont utilisées.
À strictement parler, le terme *séquence de contrôle* comporte deux sous-catégories : *mot de contrôle* et *symbole de contrôle*:
* *mot de contrôle*: une séquence de caractères avec `\catcode` lettre (11) ;
* *symbole de contrôle*: un seul caractère dont le `\catcode` est *ne* code de catégorie est lettre (11).
À ce stade, le `\` caractère d’échappement a rempli sa fonction et n’a plus lieu d’être. Lorsqu’il détecte un caractère d’échappement, la réaction de TeX est de commencer à lire tous les caractères suivants de l’entrée afin de détecter un mot de contrôle ou un symbole de contrôle.
Après le `\`, TeX détecte immédiatement le `d`: un caractère dont le `\catcode` est 11, ce qui indique à TeX qu’il a trouvé la première lettre d’un *mot de contrôle*. Il continue à analyser les caractères suivants jusqu’à ce qu’il détecte enfin un caractère qui *ne déclenche pas* devez `\catcode` lettre (11). Tous les caractères suivants (après le `\`) `\catcode` 11 (lettre) sont considérés comme formant le nom d’un mot de contrôle : c’est-à-dire le nom d’une commande — peut-être une macro ou une primitive, mais TeX ne sait pas encore de quel type de commande il s’agit. À ce stade, ce n’est qu’une chaîne de caractères.
Ainsi, dans notre exemple, TeX avance tranquillement en analysant, en vérifiant chaque caractère, jusqu’à ce qu’il atteigne le `\` de `\ohyeah` qui a lui aussi `\catcode` 0. TeX reconnaît qu’il a trop lu et remet poliment ce `\` dans le flux de texte afin qu’il devienne le prochain caractère à être vu lors de la poursuite de l’analyse du texte. À ce stade, TeX a identifié une chaîne (`def`) qu’il sait constituer le texte d’un mot de contrôle composé de trois caractères, chacun avec `\catcode` 11 (`d`, `e` et `f`). Ce que TeX doit maintenant faire est de découvrir ce que `def` signifie : que doit-il faire ? Comme vous l’avez peut-être deviné, TeX doit trouver le code de commande et l’identifiant de commande de `def` afin de pouvoir déterminer quoi faire de cette commande.
## Faire un hachage
Après avoir détecté un mot de contrôle (`def`), la première chose que fait TeX est de « convertir » la chaîne de caractères (`def` dans notre exemple) en un entier en utilisant ce qu’on appelle une fonction de hachage. Nous n’avons pas besoin d’entrer dans les détails, un aperçu suffira. En substance, TeX examine chaque caractère du mot de contrôle qu’il vient de détecter et utilise la valeur du code ASCII (ou la valeur Unicode pour XeTeX/LuaTeX) de chaque caractère pour calculer un nombre appelé valeur de hachage : ce n’est qu’un simple entier.
Dans le cadre de ce processus de calcul de hachage, TeX vérifie également si la chaîne de caractères du mot de contrôle nouvellement détecté lui est déjà connue. Le texte lisible par l’humain de toutes les commandes, qu’il s’agisse de primitives ou de macros définies par l’utilisateur, est stocké dans une zone de stockage interne appelée le *pool de chaînes*. TeX doit faire cela parce qu’il peut avoir besoin d’afficher le nom lisible par l’humain d’une commande — par exemple, lorsque TeX doit signaler une erreur et fournir le nom de la commande fautive. Par exemple, notre macro `\def\ohyeah{Overleaf is cool!}` définit une nouvelle commande appelée `\ohyeah` et TeX devra (à un stade ultérieur) non seulement calculer une valeur de hachage pour `ohyeah` (*sans* le caractère initial `\` caractère) mais aussi stocker la chaîne de texte (lisible par l’humain) au cas où il faudrait l’utiliser pour le signalement d’erreurs (ou d’autres tâches).
site de mon blog personnel [site de mon blog personnel](http://www.readytext.co.uk/?p=3590).
Le résultat final est que la chaîne de caractères représentant la commande `def` est transformée en la valeur numérique 1218 (c’est la valeur réelle calculée par TeX). À ce stade, les caractères individuels `d`, `e` et `f` ne font plus partie de l’histoire principale — ils ont été lus depuis l’entrée et ont accompli leur tâche : désormais, il n’est plus question que d’entiers et de *jetons*—nous verrons bientôt ce qu’est réellement un jeton ! En interne, TeX désigne ces nombres de valeur de hachage comme la *séquence de contrôle courante* mais dans le code source, ce terme est abrégé en une variable appelée `curcs`. Le code source de TeX regorge de noms de variables très courts, souvent assez cryptiques.
Mais que fait TeX *en réalité* avec cette valeur entière fraîchement créée de 1218 ? Comment TeX découvre-t-il que la chaîne originale `def`, désormais représentée par l’entier 1218, renvoie en réalité à une instruction de définition d’une macro ? La réponse est que TeX dispose d’une sorte de « classeur » interne où il stocke le sens et la valeur actuels de chaque commande qu’il connaît actuellement — qu’il s’agisse d’une macro définie par l’utilisateur ou d’une primitive intégrée. Si TeX s’est donné la peine de convertir `def` en la valeur de hachage 1218 (désormais stockée dans la variable appelée `curcs`) est de l’utiliser pour rechercher la *signification* de `def`. TeX répétera bien sûr cet exercice de calcul de hachage pour tous les mots de contrôle qu’il détecte dans l’entrée — bien que, bien sûr, des mots de contrôle différents produisent des valeurs entières différentes avec la fonction de hachage : c’est tout le principe.
Le « classeur » interne de TeX est appelé la *table des équivalents* et fait l’objet de la section suivante.
### Consulter la table des équivalents
Pour récapituler, voyons ce que nous avons appris jusqu’ici :
* `\` introduit le début d’une séquence de contrôle (soit un *symbole de contrôle* ou un *mot de contrôle*).
* Si le premier caractère après le `\` a `\catcode` 11 (lettre), alors il s’agit du début d’un *mot de contrôle*.
* Pour *mots de contrôle* TeX parcourt l’entrée pour vérifier tous les caractères suivants qui ont `\catcode` 11 et s’arrêtera dès qu’il trouvera le premier caractère qui n’a pas *ne* avoir un `\catcode` de 11.
* La chaîne de caractères d’entrée (suivant le `\`) qui ont `\catcode` 11 est considérée comme un *mot de contrôle* que l’utilisateur a saisi : une commande demandant à TeX de « faire quelque chose ».
* Pour commencer le processus de « faire quelque chose », TeX convertit la chaîne de caractères du mot de contrôle en un entier. Il le fait à l’aide d’une soi-disant fonction de hachage qui produit un entier.
* L’entier (valeur de hachage calculée) est désigné comme le *séquence de contrôle courante*s, mais TeX lui donne le nom plus court de `curcs`.
* Dans notre exemple, le mot de contrôle `def` est converti en la valeur 1218 — qui est stockée dans une variable appelée `curcs` : c’est-à-dire `curcs=1218`.
TeX doit maintenant découvrir ce que le *séquence de contrôle courante* signifie réellement — que fait TeX avec lui ?
#### Une note sur le groupement : la nécessité d’enregistrer et de restaurer des informations
Ici, nous ferons un petit détour pour nous rappeler que TeX a la capacité d’enregistrer et de restaurer des informations : autrement dit, il dispose d’une sorte de « mémoire » intégrée.
Quiconque a écrit la plus simple des macros devrait connaître le mécanisme de groupement de TeX — par exemple, en utilisant `\def` pour créer des macros à l’intérieur d’un groupe. À moins d’appliquer le `\global` préfixe à `\def`-créées définies à l’intérieur d’un groupe, la valeur ou le sens de cette macro ne persiste qu’à l’intérieur de ce groupe (et de ceux qui lui sont imbriqués) : sa définition est perdue lorsque le groupe se termine. Par exemple, si vous définissez une simple macro à l’intérieur d’un groupe, comme ceci :
```latex
{\def\foo{Hello}}
```
et essayez d’utiliser `\foo` hors du groupe
```latex
{\def\foo{Hello}}% \foo défini à l’intérieur d’un groupe (note : sans utiliser \global)
\foo %<--- n’est plus défini, désormais indéfini
```
alors on obtient la célèbre erreur : `Séquence de contrôle indéfinie`. `\foo` n’a de sens qu’à l’intérieur du groupe (et de ses sous-groupes) dans lequel elle a été définie. De plus, lorsque vous redéfinissez une macro à l’intérieur d’un groupe, la nouvelle valeur peut être perdue lorsque le groupe se termine et que le sens précédent (qui existait en dehors du groupe) est restauré.
```latex
\def\foo{Goodbye}
\foo\par% Produit Goodbye
{\def\foo{Hello}% Redéfinie à l’intérieur d’un groupe :
{À l’intérieur du groupe de 2e niveau : \foo\par}}% Utilisée à l’intérieur du groupe de 2e niveau : \foo produit Hello
Hors du groupe, l’ancienne valeur est restaurée : \foo\par% Produit Goodbye
```
Le but de ces exemples simples est de montrer que TeX possède une sorte de « mécanisme de stockage » ou de « mémoire » qui sauvegarde/restaure le « sens » des commandes — et, bien sûr, c’est le cas. Nous l’avons évoqué dans la section précédente : ce « mécanisme de stockage » ou « classeur » est une grande table interne appelée la *table des équivalents*. C’est là que TeX stocke le sens ou les valeurs actuels de toutes les commandes qu’il connaît actuellement — les primitives intégrées et les macros définies par l’utilisateur.
### La table des équivalents : par analogie
Pour expliquer la table des équivalents, nous procéderons par analogie. Nous continuerons à utiliser l’idée d’un classeur avec des milliers de petits tiroirs, chacun étiqueté par un entier unique. À ce stade du traitement, TeX dit en substance :
« D’accord, j’ai cette valeur entière de 1218 que je viens de calculer et d’enregistrer dans une variable appelée `curcs`. Je dois maintenant découvrir ce qu’elle signifie : pour cela, j’irai regarder dans le tiroir numéro 1218 de mon classeur pour voir ce qu’il y a écrit dedans. »
TeX utilise 1218 pour localiser le bon tiroir et y trouve une petite note qui contient trois informations dont les noms sont ceux utilisés dans le code source de TeX :
* **`eq_level :`** le niveau de groupement auquel cette entrée a été définie (niveau 1 = défini globalement). Nous avons vu les effets du groupement en action ci-dessus : c’est ici, dans la table des équivalents, que cette information de niveau de groupement est stockée ;
* **`eq_type :`** le code de commande de cette entrée ;
* **`equiv :`** valeur « courante » de cette entrée — il peut s’agir d’un simple entier, comme le modificateur de commande mentionné plus haut, ou un pointeur vers une zone mémoire ; par exemple, l’emplacement mémoire de l’ensemble de jetons représentant une définition de macro.
Ainsi, notre valeur de hachage 1218 (enregistrée dans la variable `curcs`) a, en pratique, été utilisée comme la *clé* pour accéder à un tiroir contenant le sens et la valeur actuels de la commande que nous avions saisie à l’origine sous la forme d’une chaîne de lettres `\def`.
Dans le code source du programme TeX, le `eq_type` de n’importe quelle commande est stocké à l’aide d’une variable appelée `curcmd` et la valeur de `equiv` est stockée dans une variable appelée `curchr`.
### Que dit la table des équivalents pour def ?
Comme indiqué, la valeur de hachage calculée pour n’importe quelle commande est enregistrée dans une variable appelée `curcs`; ainsi, pour `def` nous avons `curcs=1218`. En examinant l’emplacement 1218 dans la table des équivalents, TeX trouvera les informations suivantes :
* `curcmd`=97. C’est le code de commande pour `\def`;
* `curchr`=0. C’est le modificateur de commande pour `\def`.
`\def` est une commande primitive (intégrée) de TeX et, à moins qu’elle n’ait été redéfinie quelque part, la troisième et dernière information devrait être `eq_level=1` indiquant que le sens de `\def` est défini globalement et n’est pas limité à un niveau de groupement inférieur. En interne, la valeur de `eq_level` attaché à une commande joue un rôle extrêmement important dans le mécanisme de groupement de TeX, mais nous n’approfondirons pas davantage ce point.
Le graphique suivant résume l’explication que nous venons de développer :
## Jetons TeX pour les commandes
Après avoir péniblement traversé les explications ci-dessus, le calcul réel des jetons TeX pour les séquences de contrôle s’avère en fait très simple. TeX utilise la valeur de `curcs` (1218) issue de la fonction de hachage pour créer un simple entier qu’il appelle un *le jeton*. Le calcul pour générer un jeton à partir de la valeur de `curcs` est :
```c
curtok = 4095 + curcs
```
TeX stocke la valeur du jeton courant (le plus récemment calculé) dans une variable appelée `curtok`.
Ainsi, en conclusion, le jeton TeX représentant la `\def` commande est `4095 + 1218 = 5313`. Et voilà pour les jetons TeX qui représentent des séquences de commande : ce ne sont rien d’autre qu’un nombre entier calculé à partir d’une valeur de table de hachage augmentée de 4095.
## Jetons TeX pour les caractères
Lorsque TeX doit créer un jeton représentant un caractère, il utilise le calcul suivant, tout aussi simple :
```c
curtok = 256*catcode + (valeur ASCII du caractère)
```
Notez que des calculs légèrement différents sont utilisés pour les moteurs prenant en charge Unicode, tels que LuaTeX.
Par exemple, le jeton TeX représentant un caractère espace avec `\catcode` un catcode 10 et une valeur ASCII de 32 est :
```c
256*10 + 32 = 2592
```
### Listes de jetons contenant des caractères
Lorsque vous créez une simple liste de jetons avec, par exemple,
```latex
\toks100={Hello}
```
TeX créera la liste de jetons suivante et la stockera en mémoire pour une utilisation ultérieure :
* 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
Au plus profond de la mémoire de TeX, le registre de jetons 100 donnera accès à l’emplacement de stockage de « Hello », enregistré sous forme de 5 valeurs de jeton : 2888, 2917, 2924, 2924, 2927. Notez que ces jetons combinent le code ASCII de chaque caractère et la valeur de son `\catcode`au moment où ils sont transformés en jetons (tokenisés). Une fois les caractères convertis en jetons de caractère, le `\catcode` valeur qui leur est attachée est permanente et est stockée dans les jetons pour une utilisation ultérieure lorsque l’utilisateur dit, par exemple, `\the\toks100`.
Comme indiqué, un jeton de caractère est calculé à partir de `256*catcode + (valeur ASCII)` alors qu’un jeton de séquence de contrôle est calculé à partir de `4095 + curcs` où `curcs` est la valeur de hachage du mot de contrôle (chaîne de texte d’une commande saisie par l’utilisateur) détecté dans l’entrée par TeX. Il convient de noter que les jetons de caractère sont toujours inférieurs à 4095. Ainsi, TeX peut facilement déterminer si un jeton particulier représente une séquence de contrôle (une commande) ou un caractère, puis déterminer quelle séquence de contrôle ou quel caractère et `\catcode` paire est encodée dans ce jeton.
---
# 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/fr/articles-approfondis/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.