> 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/autres-sujets/21-how-tex-macros-actually-work-part-3.md).
# Comment fonctionnent réellement les macros TeX : partie 3
[Partie 1](/latex/fr/autres-sujets/19-how-tex-macros-actually-work-part-1.md) [Partie 2](/latex/fr/autres-sujets/20-how-tex-macros-actually-work-part-2.md) [Partie 3](/latex/fr/autres-sujets/21-how-tex-macros-actually-work-part-3.md) [Partie 4](/latex/fr/autres-sujets/22-how-tex-macros-actually-work-part-4.md) [Partie 5](/latex/fr/autres-sujets/23-how-tex-macros-actually-work-part-5.md) [Partie 6](/latex/fr/autres-sujets/24-how-tex-macros-actually-work-part-6.md)
## Il est temps de faire une pause !
Avant de passer à la partie suivante de cette histoire, nous devons faire un récapitulatif : nous rappeler où nous allons et rassembler nos idées pour nous assurer que toutes les idées clés sont bien en place. Petit rappel : notre exemple travaillé repose sur l’hypothèse que TeX a lu une ligne de texte contenant `Hello World \jobname` et que TeX la compose pour construire un paragraphe.
### L’objectif ultime
Notre objectif est de développer une meilleure (plus profonde) compréhension de la nature des macros TeX et de leur fonctionnement. Cependant, pour y parvenir, nous devons d’abord comprendre comment TeX lit un fichier d’entrée et traite les caractères qu’il contient. Voici un résumé des sujets abordés jusqu’à présent.
* TeX lit (analyse) chaque caractère de votre entrée et, pour chaque caractère, TeX dispose de deux informations :
* **code de caractère**: un entier utilisé pour identifier ce caractère, par exemple lorsqu’il est stocké dans un fichier d’entrée .tex ;
* **code de catégorie**: un autre entier, interne à TeX, qu’il utilise pour attribuer un sens à chaque caractère lu depuis l’entrée.
* Dès qu’un caractère est lu par TeX, le code de catégorie de chaque caractère devient *de manière permanente* associé à ce caractère individuel par la création d’un jeton de caractère :
* TeX utilise une formule simple pour « emballer » ensemble un code de caractère et son code de catégorie correspondant dans un entier appelé jeton de caractère.
* Vous pouvez changer le sens de n’importe quel caractère que TeX n’a *pas encore lu* en attribuant un code de catégorie différent à tout caractère dont vous souhaitez changer le comportement — c’est-à-dire modifier la façon dont TeX traite ce caractère.
* La redéfinition (remappage) des codes de catégorie s’effectue à l’aide du primitif TeX `\catcode` commande.
* Lorsque TeX voit un code de catégorie de 0, il passe en mode d’analyse spécial et commence à chercher une commande : soit un *mot de contrôle* à plusieurs lettres *symbole de contrôle*.
Jusqu’à présent, nous avons considéré le processus d’analyse de l’entrée par TeX lorsqu’il identifie des caractères individuels et utilise le code de catégorie de chaque caractère afin de déterminer quoi faire ensuite. Certains caractères ne sont que de simples éléments de texte à composer (par ex., code de catégorie 11), mais nous avons aussi vu des caractères d’espacement (code de catégorie 10) et des caractères d’échappement (code de catégorie 0). Il existe d’autres codes de catégorie que, par souci de concision, nous n’avons pas examinés — comme le code de catégorie 1 (« début de groupe », par ex., `{`), code de catégorie 2 (« fin de groupe », par ex., `}`) et d’autres. Chaque code de catégorie joue son propre rôle dans l’analyse de l’entrée par TeX et dans le traitement ultérieur par les processus/algorithmes logiciels à l’intérieur de TeX.
### Jetons : un rapide récapitulatif
Le concept de « jetons » est central dans le fonctionnement de TeX : vous verrez les « jetons » mentionnés ou évoqués tout au long des livres, articles et communautés en ligne consacrés à TeX, il vaut donc la peine de revoir brièvement ce sujet — vous trouverez plus de détails dans un article publié précédemment [Qu’est-ce qu’un « jeton TeX » ?](/latex/fr/articles-approfondis/53-what-is-a-tex-token.md)
Nous avons déjà vu que TeX convertit les caractères d’entrée en jetons en combinant le code de caractère et le code de catégorie en un seul entier composite. TeX fait quelque chose de similaire pour les commandes : en utilisant le nom de la commande, il calcule un entier appelé un *jeton de commande* (nous l’explorerons plus en détail). À titre indicatif, vous pouvez considérer les jetons comme la manière dont TeX « emballe » les éléments qu’il a lus dans l’entrée, en les préparant pour leur envoi à l’étape suivante du traitement de TeX. Le fait que tous les éléments (caractères ou commandes) soient soigneusement enveloppés dans une seule représentation numérique facilite leur traitement plus loin dans la chaîne. Par exemple, lorsque TeX veut stocker une partie de votre entrée pour l’utiliser plus tard, comme une définition de macro, TeX a seulement besoin d’enregistrer votre définition de macro, aussi complexe soit-elle, sous forme d’une suite d’entiers, où chaque entier est un jeton représentant un caractère ou une commande qui fait partie de (est contenue dans) la définition de votre macro.
## Alors, quelle est la suite ?
Dans la section finale de la partie 2, nous avons vu comment un caractère d’échappement (code de catégorie 0) fait passer TeX en mode de traitement spécial, où il recherche le nom d’une commande. Dans notre exemple, TeX a détecté la suite de caractères `jobname` et nous avons terminé la partie 2 au moment où TeX allait « faire quelque chose » avec cette suite de caractères (nom d’une commande). Dans cette partie, nous allons examiner en détail ce que TeX fait ensuite.
Une fois que TeX a identifié qu’une certaine suite de caractères dans votre fichier d’entrée représente le nom d’une commande (ici, `jobname`) TeX peut, selon ce qu’il est en train de faire, avoir besoin d’exécuter cette commande. Nous disons « peut avoir besoin de » parce qu’il arrive que TeX n’essaie pas immédiatement d’exécuter une commande : par exemple, lorsqu’il définit une macro (TeX construit des listes de jetons) — sujets que nous aborderons plus tard. Toutefois, nous continuerons à suivre notre exemple où TeX compose un paragraphe et *va*, dans cette situation, avoir besoin d’exécuter `\jobname`.
### D’une suite de caractères à l’exécution d’une commande : comment ?
Tout d’abord, revenons à la figure 5b de la partie 2 dans laquelle TeX a identifié qu’une certaine suite de caractères dans l’entrée constitue le nom d’une commande : `jobname`. La figure 5b indique que TeX doit « vérifier les tables internes… ». Qu’est-ce que cela *signifie réellement*?
Une autre description, plus détaillée, de la manière dont TeX « vérifie les tables internes » pour passer d’une suite de caractères (par ex., `jobname`) à la détermination exacte de la commande et de sa signification, se trouve dans un article précédent [Qu’est-ce qu’un « jeton TeX » ?](/latex/fr/articles-approfondis/53-what-is-a-tex-token.md) Ici, nous résumerons les idées clés tout en essayant d’éviter une duplication excessive.
Commençons par une analogie. Supposons que vous lisiez un livre et tombiez sur un mot inconnu : que faites-vous ? Aujourd’hui, c’est presque certainement « chercher sur Google », mais supposons que vous préfériez une méthode plus ancienne : vous prenez un dictionnaire qui répertorie les mots et fournit leur(s) signification(s). TeX a un mécanisme analogue : un « dictionnaire » interne qui répertorie toutes les commandes actuellement connues de TeX — ainsi que la « signification » de ces commandes. Par « signification », nous entendons de quel type de commande il s’agit : ce qu’elle fait, plus toute autre information dont TeX pourrait avoir besoin pour exécuter cette commande. Notez aussi que le terme « commande » inclut toutes les macros TeX/LaTeX écrites par les utilisateurs/programmeurs TeX et les [des centaines de commandes primitives intégrées](/latex/fr/autres-sujets/46-tex-primitives-listed-by-tex-engine.md).
Poursuivons notre analogie avec le dictionnaire. Quand, en tant que lecteur humain, nous devons chercher la signification d’un mot, nous recherchons dans le dictionnaire en utilisant le classement alphabétique des mots fourni par le dictionnaire — mais, bien sûr, TeX ne fonctionne pas tout à fait ainsi. Revenons à notre `jobname` exemple initial, comment TeX trouve-t-il, dans son « dictionnaire », la « signification » de `jobname`— et que fournit exactement cette « signification » à TeX ?
Plutôt que de fournir un « classement alphabétique » interne de toutes les commandes que TeX connaît, il fait quelque chose d’un peu différent. TeX convertit l’ensemble de la séquence de caractères — présente dans le nom d’une commande — en un seul entier, qui servira à identifier (représenter) cette commande. En interne, TeX maintient un grand « dictionnaire » de toutes les commandes connues, dans lequel il enregistre/stocke les *entiers* calculés à partir des noms de commande — notez que ce dictionnaire ne stocke pas les noms de commande eux-mêmes sous forme de suites de lettres (appelées *chaînes de caractères*). TeX utilise ce dictionnaire pour toutes ses commandes intégrées (primitives) *et* il l’utilisera pour stocker les détails de toute macro (commande) créée par les utilisateurs : le nom de votre macro est transformé en un entier et cet entier est « enregistré » dans le dictionnaire de TeX.
Chaque fois que TeX détecte une commande utilisée dans votre entrée, et qu’il a besoin de connaître quelque chose à propos de cette commande, il convertit la suite de caractères du nom de la commande en un entier « équivalent » et utilise cet entier pour rechercher la commande dans son « grand dictionnaire ». Les programmeurs parmi vous voudront peut-être savoir que TeX utilise une forme de [fonction de hachage](https://en.wikipedia.org/wiki/Hash_function) hachage
### Figure 6 : Des caractères à la signification d’une commande
Le graphique suivant montre le parcours qu’une commande suit lorsque TeX convertit la suite de caractères en un entier équivalent, qu’il appelle **curcs**, et utilise cet entier pour rechercher la signification de la commande dans le « grand dictionnaire » de TeX. Le résultat de cette recherche est constitué de deux informations : deux entiers, appelés **curcmd** et **curchr**, que TeX peut utiliser pour déterminer exactement ce que fait la commande et comment l’exécuter ensuite.
En interne, TeX maintient une variable appelée **curcs** (**cour**ant **c**contr **e**séquence) qui est utilisée pour stocker la valeur entière de la commande sur laquelle TeX travaille actuellement — c’est-à-dire, **curcs** stocke la valeur entière calculée à partir du nom de la commande. Ce n’est pas tout à fait toute l’histoire, car il reste un détail : si TeX vient de lire/traiter un caractère, et non une commande, il définira **curcs** à la valeur 0, pour se souvenir que le dernier élément lu était un caractère, et non une commande.
### Ce que les commandes signifient pour TeX
Si nous examinons l’ensemble des [commandes intégrées fournies par les moteurs TeX](/latex/fr/autres-sujets/46-tex-primitives-listed-by-tex-engine.md) nous pouvons voir que certaines de ces commandes sont étroitement liées : elles accomplissent des tâches similaires ; par exemple, il existe 4 commandes primitives que tous les moteurs TeX utilisent pour définir (créer) des macros : `\def`, `\gdef`, `\edef`, `\xdef`. Ces 4 commandes définissent toutes des macros mais, bien sûr, chacune le fait légèrement différemment. Si nous examinons cela d’un point de vue de programmation : nous avons ici 4 commandes de définition de macros qui, globalement, font la même chose mais entre lesquelles nous devons choisir afin de tenir compte de leur comportement individuel.
Pour gérer cela, TeX attribue deux valeurs à chaque commande et ces deux valeurs constituent ce que TeX comprend comme la « signification » d’une commande (son rôle/ce qu’elle fait) — ces deux valeurs sont internes à TeX, profondément enfouies dans le logiciel, et font partie du « mécanisme interne » inaccessible aux utilisateurs. Toute commande TeX, qu’il s’agisse d’un primitif intégré ou d’une commande définie par l’utilisateur, reçoit deux valeurs qui, pour TeX, définissent/classent son comportement — ce qu’elle signifie pour TeX. Lorsque TeX utilise son « grand dictionnaire » pour rechercher une commande, il trouvera ces deux informations essentielles :
* **code de commande**: une sorte de « classification générale » indiquant de quel « type » de commande il s’agit — comme une commande de « définition de macro » (l’une des `\def`, `\gdef`, `\edef`, `\xdef`); une commande de « fabrication de boîte » (l’une des `\hbox`, `\vbox` ou `\vcenter`) et ainsi de suite pour les centaines de commandes prises en charge par les moteurs TeX. Les macros (commandes définies par l’utilisateur) reçoivent également un code de commande.
* **modificateur de commande**: C’est une information annexe qui fournit à TeX des renseignements spécifiques sur une commande. Les macros (commandes définies par l’utilisateur) reçoivent également un modificateur de commande — bien que, pour les macros, le modificateur de commande joue un rôle légèrement différent de celui qu’il joue pour les primitifs (pour les macros, le modificateur de commande indique où la définition de la macro est stockée en mémoire).
Pris ensemble, le code de commande et le modificateur de commande identifient de façon unique chaque commande. Voici les codes de commande et les modificateurs de commande pour les commandes de définition de macros telles qu’elles sont utilisées par le logiciel TeX original de Knuth — notez que d’autres moteurs TeX peuvent utiliser des valeurs différentes, mais ils suivent exactement le même principe :
| | | |
| ------------ | --------------------------------------------------------- | ----------------------------------------------------------------- |
| **Commande** | Commande
code
| Commande
modificateur
|
| `\def` | 97 | 0 |
| `\gdef` | 97 | 1 |
| `\edef` | 97 | 2 |
| `\xdef` | 97 | 3 |
### Récapitulatif : donner du sens à toutes ces variables/valeurs
À ce stade, nous sommes submergés par une foule d’informations sur les valeurs, les variables, les valeurs des commandes et toutes sortes de détails — cela peut vite devenir confus, alors faisons le point sur ce que nous savons. Quand TeX lit quelque chose dans votre entrée, c’est soit un caractère, soit une commande. Chaque fois que TeX lit quelque chose dans l’entrée, il doit stocker des informations sur ce qu’il vient de lire (analyser) :
* Pour **caractères**: il doit enregistrer le code du caractère et le code de catégorie. Il doit aussi créer et stocker la valeur de jeton que TeX calcule à partir de ces valeurs.
* Pour **commandes**: TeX doit connaître l’équivalent numérique, **curcs**, qu’il a calculé à partir du nom de la commande. Il peut aussi devoir stocker la « signification » qu’il a récupérée en recherchant la commande dans le « dictionnaire » de TeX : le code de commande et le modificateur de commande. En plus de cela, TeX devra également calculer une valeur de jeton qui représente cette commande.
Oui, c’est confus : beaucoup de variables et d’idées de jetons qui flottent partout, alors essayons de mettre de l’ordre dans tout cela.
En interne, TeX utilise quatre variables globales pour stocker des informations sur le dernier élément que TeX a lu (ou sur lequel il travaille actuellement) — nous n’entrerons pas dans le détail de ces variables, mais connaître leur existence aide à donner un peu plus de contexte pour comprendre ce qui se passe réellement :
* **curcmd**: (commande courante) une variable entière. Elle est utilisée pour stocker la *commande courante* valeur de la commande en cours de traitement *ou* elle stocke la *code de catégorie* du caractère en cours de traitement ;
* **curchr**: (caractère courant) une variable entière, mais ce qu’elle stocke dépend de ce que TeX vient de lire dans son entrée :
* **suivant**: Si l’élément lu le plus récemment est un caractère, **curchr** stocke le code du caractère courant *code de caractère*.
* **commande**: Si l’élément lu le plus récemment est une commande, **curchr** stocke le modificateur de commande courant *modificateur de commande*: information supplémentaire que TeX utilise pour prendre en charge/clarifier **curcmd**— parce que, comme nous l’avons vu plus haut, certaines commandes partagent la même valeur de **curcmd**
* **curcs**: (séquence de contrôle courante) une variable entière qui stocke la valeur calculée à partir de la suite de caractères contenue dans le nom d’une commande. **curcs** = 0 si le dernier élément lu était un caractère individuel et non le nom d’une séquence de contrôle (un nom de commande) ;
* **curtok**: (jeton courant) une variable entière qui contient la valeur du jeton courant — qui est soit un jeton de commande, soit un jeton de caractère.
Voici les informations ci-dessus présentées sous forme de tableau :
| | | |
| ---------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Variable globale utilisée dans TeX :** | **Quand TeX analyse un caractère :** | **Quand TeX analyse une commande :** |
| **curcmd** | Stocke le code de catégorie du caractère courant | Stocke le *code de commande*— qui identifie le « type » de la commande courante |
| **curchr** | Stocke le code du caractère courant | Stocke des données supplémentaires (appelées le *modificateur de commande*) qui fournissent des informations supplémentaires sur la commande courante |
| **curcs** | 0 | Un entier positif non nul calculé (via une fonction de hachage) à partir de la suite de caractères présente dans le nom d’une commande. Il est utilisé pour accéder au « dictionnaire » de TeX afin de rechercher la signification actuelle d’une commande — pour récupérer son code de commande et son modificateur de commande. |
| **curtok** | Pour les moteurs TeX 8 bits, un *jeton de caractère* est calculé à l’aide de la formule : $$\text{curtok}=256\times \text{curcmd} + \text{curchr}$$ où $$\text{curcmd}$$ est le code de catégorie du caractère et $$\text{curchr}$$ est le code du caractère | Pour les moteurs TeX 8 bits, un *jeton de commande* est calculé à l’aide de la formule : $$\text{curtok}=4095 + \text{curcs}$$ |
### Remarques supplémentaires sur le jeton courant
Pour les caractères, la valeur maximale possible du jeton est obtenue en utilisant le plus grand code de catégorie (15) et le plus grand code de caractère qui, pour les moteurs TeX 8 bits, est 255. En théorie (pour les moteurs TeX 8 bits), la valeur maximale d’un jeton de caractère, $$\text{curtok}\_{\text{max}}$$, est :
$$\text{curtok}\_{\text{max}}= 256\times 15 + 255 = 4095$$
Nous disons « en théorie » parce que le code de catégorie 15 est utilisé pour représenter un « caractère invalide » qui provoque une erreur dans TeX : un caractère invalide ne franchira jamais le processus d’analyse d’entrée de TeX et ne deviendra donc jamais un jeton de caractère.
Pour les commandes, le jeton courant ($$\text{curtok}$$) est calculé à partir de $$\text{curtok}=4095 + \text{curcs}$$ mais pour les commandes $$\text{curcs}$$ est *toujours* non nul, donc TeX peut facilement déterminer ce que représente un jeton :
* Si $$\text{curtok} > 4095$$ alors c’est un jeton de commande ;
* Si $$\text{curtok} < 4095$$ c’est un jeton de caractère.
En pratique, TeX utilise les jetons, une simple valeur entière, pour « emballer » toutes les informations qu’il lui faut connaître sur un élément lu dans l’entrée.
## Partie 4
Dans la partie 4, nous explorons une gamme de macros d’exemple pour démontrer le rôle et la fonction du `` section afin d’agir comme un « modèle de jetons » qui peut être construit à l’aide de jetons délimiteurs.
[Partie 1](/latex/fr/autres-sujets/19-how-tex-macros-actually-work-part-1.md) [Partie 2](/latex/fr/autres-sujets/20-how-tex-macros-actually-work-part-2.md) [Partie 3](/latex/fr/autres-sujets/21-how-tex-macros-actually-work-part-3.md) [Partie 4](/latex/fr/autres-sujets/22-how-tex-macros-actually-work-part-4.md) [Partie 5](/latex/fr/autres-sujets/23-how-tex-macros-actually-work-part-5.md) [Partie 6](/latex/fr/autres-sujets/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/fr/autres-sujets/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.