> 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/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md). # Comment fonctionne \expandafter : introduction aux jetons TeX [Partie 1](/latex/fr/articles-approfondis/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Partie 2](/latex/fr/articles-approfondis/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Partie 3](/latex/fr/articles-approfondis/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Partie 4](/latex/fr/articles-approfondis/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Partie 5](/latex/fr/articles-approfondis/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Partie 6](/latex/fr/articles-approfondis/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.md) ## Contexte pour \expandafter : les jetons TeX et les listes de jetons Comme première étape pour comprendre comment `\expandafter` fonctionne réellement, nous allons examiner deux composants de TeX qui sont fondamentaux au fonctionnement de `\expandafter`: les jetons TeX (nombres entiers) et les listes de jetons (listes d'entiers). Les lecteurs qui souhaiteraient explorer ces sujets beaucoup plus en détail pourront être intéressés par la lecture des articles suivants publiés par Overleaf : * [Qu'est-ce qu'un jeton TeX ?](/latex/fr/articles-approfondis/53-what-is-a-tex-token.md) * [Qu’est-ce qu’une liste de jetons TeX ?](/latex/fr/articles-approfondis/54-what-is-a-tex-token-list.md)-[Comment fonctionnent réellement les macros TeX ?](/latex/fr/autres-sujets/01-a-six-part-series-how-do-tex-macros-actually-work.md) ### D'où viennent les données des jetons ? Tout au long de cet article, nous utilisons les valeurs réelles des jetons calculées par TeX — des données généralement inaccessibles aux utilisateurs. Pour les lecteurs curieux de savoir comment ces données de valeur de jeton ont été obtenues, Overleaf dispose de compilations personnalisées de plusieurs moteurs TeX que nous utilisons pour la recherche. Ces moteurs sont modifiés pour afficher des informations sur les activités de traitement internes de TeX — ce qui aide à fournir du matériel contextuel supplémentaire pour certains des articles que nous produisons. En présentant et en discutant des valeurs numériques de jetons, notre objectif est d'inclure des détails qui, nous l'espérons, aident les lecteurs à mieux comprendre les « jetons TeX », en rendant ce concept important un peu moins opaque. ## Les jetons TeX 101 (et notions d'expansion) Lorsque TeX traite votre fichier d'entrée, il lit le texte et convertit les caractères individuels et les séquences de caractères (commandes) en ce que l'on appelle *jetons*. Un jeton TeX est simplement une valeur entière, calculée par TeX, qui est utilisée pour « encoder » des données que TeX doit stocker à propos d'un élément lu depuis sa source d'entrée actuelle. Considérez les jetons comme de petits paquets d'informations qui « regroupent » des données que TeX doit enregistrer, prêtes à être transmises à l'étape suivante du traitement. En interne, TeX fonctionne sur ces valeurs entières de jetons — il n'utilise pas les lettres, symboles, chiffres, etc. réellement contenus dans votre fichier d'entrée : tout est converti en un jeton (un entier) et TeX travaille avec ceux-ci. ## Comment TeX calcule les valeurs des jetons Ici, nous examinons les calculs de jetons utilisés dans le TeX original de Knuth, e-TeX et pdfTeX ; pour d'autres moteurs TeX, en particulier XeTeX et LuaTeX, leurs calculs de jetons doivent être légèrement différents pour prendre en compte l'utilisation d'Unicode, mais les méthodes de calcul sont similaires à celles décrites ci-dessous. ### Jetons de caractères (caractères non actifs) Le calcul des valeurs des jetons pour les caractères non actifs est simple : $$\text{character token} = 256\times \text{(category code)} + \text{character (ASCII) code}$$ **Exemple**: La lettre A avec [code de catégorie](/latex/fr/autres-sujets/43-table-of-tex-category-codes.md) 11, le code de caractère 65 est représenté par TeX sous la valeur du jeton de caractère $$256\times 11 + 65 = 2881$$. Vous pourriez rencontrer dans la littérature TeX des descriptions indiquant qu'une fois que TeX a lu un caractère, la valeur de son code de catégorie devient « définitivement liée » à ce caractère : le calcul de valeur de jeton ci-dessus montre pourquoi cela est vrai. Cependant, plus tard dans le traitement de TeX, il peut, et il le fait, « déballer » les jetons de caractères pour révéler la paire constituante (code de caractère, code de catégorie) à partir de laquelle le jeton a été construit — lorsque TeX fait ce « déballage », il ne modifiera toujours pas le code de catégorie de ce caractère, il utilisera simplement cette information lors de son traitement ultérieur. ### Jetons de commande Le traitement de l'entrée et la génération de jetons de TeX reconnaissent deux types de commande : * des commandes construites à partir d'un ou plusieurs caractères ayant le code de catégorie 11 ; * des commandes à caractère unique dont le code de catégorie de ce caractère n'est pas 11, comme `\$` ou `\#`. Dans les deux cas, TeX exclut le `\` caractère initial et utilise le code de caractère de chacun des caractères restants pour calculer un entier que TeX appelle `curcs` (**cour**ant **c**contr **e**séquence). TeX utilise ensuite la valeur de `curcs` pour calculer une valeur de jeton pour la commande. #### Commandes formées de caractères ayant le code de catégorie 11 Supposons que notre commande (sans le `\` caractère initial) soit composée d'une séquence de caractères : $$\mathrm{C\_1C\_2C\_3...C\_N}$$ où $$\mathrm{C}\_i$$ est le code de caractère de chaque caractère — par exemple, le code de caractère de A est 65. TeX utilise tous les codes de caractère $$\mathrm{C}\_i$$ pour calculer l'entier `curcs` (à l'aide d'une [fonction de hachage](https://en.wikipedia.org/wiki/Hash_function)). Une fois que TeX a calculé la valeur de `curcs` il ajoute simplement 4095 à cette valeur pour obtenir la valeur du jeton : $$\text{command token} = \text{curcs + 4095}$$ Notez que la variable `curcs` joue un rôle extrêmement important dans les activités de traitement internes de TeX. #### Commandes à caractère unique Les jetons représentant des commandes telles que `\$`, `\#` etc. sont soumis à un calcul légèrement différent : l'entier `curcs` correspond maintenant au calcul plus simple suivant : $$\text{curcs} = 257 + \text{character (ASCII) code}$$ Par exemple, avec `\$`, $$\text{curcs}=257 + 36 = 293$$. TeX ajoute à nouveau 4095 à cette valeur (en utilisant $$\text{command token} = \text{curcs} + 4095$$) ce qui donne `\$` ayant une valeur de jeton $$293 + 4095 = 4388$$. Par rapport aux commandes composées de caractères ayant le code de catégorie 11, la seule différence ici est la façon dont TeX calcule la valeur de `curcs`. **Remarque**: l'entier `curcs` n'est pas calculé pour les jetons de caractère : il est toujours fixé à 0 lorsque TeX crée des jetons de caractère ou travaille avec eux. #### Jetons de caractères actifs TeX a le concept de ce qu'on appelle des *caractères actifs*: tout caractère auquel est attribué le code de catégorie 13. Les jetons pour cette classe spéciale de caractères sont soumis à un calcul différent de celui des caractères ordinaires. Le mécanisme des caractères actifs permet à TeX de créer ce qui est, en pratique, des macros à un seul caractère que vous pouvez utiliser *sans* sans avoir à faire précéder le caractère actif d'un caractère d'échappement (généralement `\`): le caractère isolé déclenchera son comportement de macro. L'exemple canonique est le caractère tilde (\~) que TeX/LaTeX utilisent pour les espaces insécables, et qui peut être défini/activé comme suit : ``` \catcode`~=13 %attribuer le code de catégorie 13 à ~ \def~{\penalty100000\ } % définir ~ pour agir comme une macro ``` Lorsque TeX lit ensuite un `~` caractère, il détectera que son code de catégorie est 13 et le traitera comme une « mini-macro ». Pour calculer un jeton représentant un caractère actif, TeX applique une autre variante de calcul de `curcs`: $$\begin{align\*} \text{curcs} &= \text{character code} + 1\ \text{active character token} &= \text{curcs} + 4095\ \end{align\*}$$ Par exemple, le caractère \~ a le code de caractère 126, ce qui signifie que sa représentation de valeur de jeton de caractère actif est calculée comme suit : $$\begin{align\*} \text{curcs} &= 126 + 1\ \text{active character token} &= 127 + 4095\ &=4222\ \end{align\*}$$ Notez que, comme les commandes, les jetons représentant des caractères actifs sont > 4095. ### Conséquences/notes * Tout jeton dont la valeur dépasse 4095 est immédiatement identifiable comme un jeton de commande — ainsi TeX peut très facilement détecter si un jeton particulier représente un caractère ou une commande. * Pour n'importe quelle valeur de jeton, TeX peut, lorsque c'est nécessaire, « déballer » ce jeton pour révéler le caractère (et son code de catégorie), ou la commande, initialement présents dans votre `.tex` fichier, stockés dans une définition de macro ou contenus dans une autre liste de jetons. * La quantité « intermédiaire » appelée `curcs`—que TeX utilise pour calculer les valeurs des jetons de commande— joue un rôle important dans le traitement de bas niveau de TeX. `curcs` sert de « valeur d'index » que TeX utilise pour stocker/rechercher la signification actuelle d'une commande. Étant donné n'importe quel jeton de commande, $$\mathrm{T}$$, TeX soustrait simplement 4095 pour accéder à la valeur de `curcs`: $$\text{curcs} = \mathrm{T}-4095$$ Par ailleurs, TeX stocke bien la chaîne de caractères lisible par l'humain à partir de laquelle un jeton de commande est généré — c'est essentiel pour le signalement d'erreurs et d'autres commandes telles que `\string` dont l'expansion est la version lisible par l'humain d'une valeur de jeton. Cependant, ces chaînes de caractères lisibles par l'humain stockées dans TeX ne sont utilisées/produites que lorsqu'on le demande : pour tout le reste du traitement, c'est la valeur entière du jeton qui est utilisée. ## Examinons quelques jetons réels Juste pour rendre la notion de jetons un peu moins opaque, nous allons définir la macro simple suivante et examiner les jetons que TeX produit : ``` \def\hello{Greetings, from \TeX. \hskip 10pt} ``` Pour les `\hello` macro, TeX utilise les caractères `h`, `e`, `l`, `l`, `o` pour calculer une valeur de 3745 pour `curcs`; TeX ajoute ensuite 4095 pour créer une valeur de jeton de $$3745 + 4095 = 7840$$ (pour TeX de Knuth, e-TeX ou pdfTeX). Après avoir créé un jeton pour représenter `\hello`, la `\def` commande, TeX lit les jetons suivants et les utilise pour créer une liste de jetons qui est stockée comme la *définition* du `\hello` commande. Cette définition stockée (liste de jetons) peut ensuite être récupérée chaque fois que vous dites à TeX d'utiliser la `\hello` commande. Le tableau suivant répertorie les valeurs réelles de jetons créées pour chaque élément (caractère, macro ou primitive) contenu dans la `\hello` définition de la macro — cette liste de jetons (entiers) est ce que TeX stocke dans sa mémoire (sous forme de structure de données appelée une [liste chaînée](https://en.wikipedia.org/wiki/Linked_list)). Les lecteurs souhaitant mieux comprendre les listes de jetons sont renvoyés à l'article Overleaf [Qu’est-ce qu’une liste de jetons TeX ?](/latex/fr/articles-approfondis/54-what-is-a-tex-token-list.md) | | | | ----------------------- | ---------------------- | | **Valeur du jeton TeX** | **Élément représenté** | | 2887 | G | | 2930 | r | | 2917 | e | | 2917 | e | | 2932 | t | | 2921 | i | | 2926 | n | | 2919 | g | | 2931 | e | | 3116 | , | | 2592 | | | 2918 | f | | 2930 | r | | 2927 | o | | 2925 | m | | 2592 | | | 5235 | \TeX | | 3118 | . | | 2592 | | | 7943 | \hskip | | 3121 | 1 | | 3120 | 0 | | 2928 | p | | 2932 | t | Dans la liste de jetons ci-dessus, les caractères ont les codes de catégorie 10, 11 ou 12. Par exemple : * les caractères ont le code de catégorie 10 et le code de caractère 32, ce qui donne une valeur de jeton de $$256\times 10 + 32 = 2592$$ * `,` et `.` ont le code de catégorie 12 et les codes de caractère 44 et 46 respectivement, ce qui donne les jetons : * jeton pour `,` $$= 256 \times 12 + 44 = 3116$$ * jeton pour `.` $$= 256\times 12+ 46 = 3118$$ Chaque fois que TeX rencontre ensuite la valeur de jeton 7840 (représentant `\hello`) il peut, si nécessaire, « déballer » ce jeton pour extraire `curcs` au moyen du simple calcul $$\text{curcs} = \text{token value} - 4095$$ (voir ci-dessus). En utilisant la valeur de `curcs` TeX peut consulter ses tables de données internes pour déterminer que le jeton de commande 7840 représente une commande de macro. De plus, toujours via `curcs`, TeX peut aussi rechercher et récupérer la définition stockée de `\hello`. Lorsque TeX doit traiter entièrement le jeton 7840, c'est-à-dire exécuter la `\hello` macro, il n'a plus besoin du jeton 7840 : ce jeton a *rempli sa fonction*—c'est-à-dire qu'il a déclenché l'exécution par TeX de la macro `\hello`. TeX peut maintenant supprimer le jeton 7840 et récupérer les jetons qui représentent la définition (liste de jetons) stockée en mémoire. En pratique, la `\hello` commande de macro (jeton 7840) a été *retirée* de la source d'entrée actuelle de TeX et *remplacée* par les jetons contenus dans la définition de `\hello`. Ce que nous venons de décrire est une forme de *expansion de jetons*. Le `\TeX` commande (valeur de jeton 5235 indiquée ci-dessus) utilisée dans `\hello` est elle-même une macro construite à partir de davantage de jetons — sa définition est donc aussi stockée sous forme de liste de jetons : | | | | ----------------------- | ---------------------- | | **Valeur du jeton TeX** | **Élément représenté** | | 2900 | T | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3126 | 6 | | 3126 | 6 | | 3127 | 7 | | 2917 | e | | 2925 | m | | 19597 | \lower | | 3118 | . | | 3125 | 5 | | 2917 | e | | 2936 | x | | 6175 | \hbox | | 379 | { | | 2885 | P | | 637 | } | | 19598 | \kern | | 3117 | - | | 3118 | . | | 3121 | 1 | | 3122 | 2 | | 3125 | 5 | | 2917 | e | | 2925 | m | | 2904 | X | Si nous remplacions la `\hello` commande par la liste complète des jetons à partir desquels elle est construite, y compris la `\TeX` macro, ce serait une liste assez longue — c'est-à-dire que si nous *développions aussi* le `\TeX` la macro, nous verrions : ![Une liste de jetons stockée dans une macro TeX](/files/af19549dac418ca74b1cf14e09af9e32057691ea) Essentiellement, la seule valeur de jeton 7840 (pour `\hello`) produirait, une fois entièrement développée, un total de 51 jetons (entiers) représentant des caractères et des commandes primitives. Dans la liste suivante, le caractère ou la commande représenté(e) par chaque jeton est indiqué(e) entre parenthèses « (...) » — ces éléments ne sont pas stockés directement dans les listes de jetons de TeX et sont présentés pour aider le lecteur : ``` 2887 (G), 2930 (r), 2917 (e), 2917 (e), 2932 (t), 2921 (i), 2926 (n), 2919 (g), 2931 (s), 3116 (,), 2592 (), 2918 (f), 2930 (r), 2927 (o), 2925 (m), 2592 (), 2900 (T), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3126 (6), 3126 (6), 3127 (7), 2917 (e), 2925 (m), 19597 (\lower), 3118 (.), 3125 (5), 2917 (e), 2936 (x), 6175 (\hbox), 379 ({), 2885 (E), 637 (}), 19598 (\kern), 3117 (-), 3118 (.), 3121 (1), 3122 (2), 3125 (5), 2917 (e), 2925 (m), 2904 (X), 3118 (.), 2592 (), 7943 (\hskip), 3121 (1), 3120 (0), 2928 (p), 2932 (t) ``` Pour un lecteur humain, il ne s'agit que d'une série d'entiers, mais pour TeX cela encode une grande quantité d'informations. ## Lire les jetons maintenant et les sauvegarder pour plus tard Lorsque TeX lit votre entrée, il peut arriver qu'il doive (ou qu'on lui demande de) retarder le traitement complet d'un certain ensemble de jetons. S'il lui est demandé de le faire, TeX continuera, jusqu'à ce qu'on lui dise d'arrêter, à créer des jetons à partir de l'entrée mais à les stocker pour une utilisation ultérieure — les récupérant ensuite et les traitant dans le cadre de ses activités de composition. Ces jetons stockés sont sauvegardés sous forme de ce qu'on appelle *listes de jetons* qui sont, en pratique, le seul mécanisme interne de stockage des données de jetons de TeX. Nous avons déjà vu des exemples de listes de jetons — les `\hello` et `\TeX` macros listées ci-dessus : la définition de ces macros est stockée dans la mémoire de TeX sous forme de listes de jetons. TeX ne traitera (n'agira sur) ces listes de jetons que lorsque vous déciderez d'appeler ces macros. N'oubliez pas non plus que chaque jeton (valeur entière) encode suffisamment d'informations pour que TeX puisse facilement déterminer si chaque jeton stocké dans une définition de macro représente un caractère ou une commande. ### Enregistrer des jetons avec des registres de jetons Un autre exemple de stockage de jetons est la création explicite de listes de jetons qui sont sauvegardées dans ce qu'on appelle des *registres de jetons*: des zones de stockage internes dédiées que TeX fournit aux utilisateurs pour stocker des listes de jetons. La primitive TeX `\toksdef` est une manière d'utiliser les registres de jetons ; par exemple, pour utiliser le registre de jetons `100` et y faire référence à l'aide de la commande `\mylist`: ``` \toksdef\mylist=100 \mylist={some \TeX{} tokens here} ``` `\mylist` n'est en réalité qu'un nom que vous attribuez à une liste de jetons stockée à l'emplacement de registre `100`. De la même manière qu'une définition de macro, `\mylist` contient la liste de jetons suivante : | | | | ----------------------- | ---------------------- | | **Valeur du jeton TeX** | **Élément représenté** | | 2931 | e | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | 379 | { | | 637 | } | | 2592 | | | 2932 | t | | 2927 | o | | 2923 | roi | | 2917 | e | | 2926 | n | | 2931 | e | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | **Remarque**: pour terminer la `\TeX` macro et l'empêcher d'absorber le `` caractère suivant, nous avons utilisé une paire d'accolades `{}` immédiatement après `\TeX`—les jetons pour `{` (379) et `}` (637) sont stockés dans la liste de jetons. Une autre option consiste à utiliser un jeton d'« espace de contrôle » `\\` qui apparaîtrait dans la liste de jetons comme indiqué ci-dessous (en gras) : | | | | ----------------------- | ---------------------- | | **Valeur du jeton TeX** | **Élément représenté** | | 2931 | e | | 2927 | o | | 2925 | m | | 2917 | e | | 2592 | | | 5235 | \TeX | | **4384** | **\\** | | 2932 | t | | 2927 | o | | 2923 | roi | | 2917 | e | | 2926 | n | | 2931 | e | | 2592 | | | 2920 | h | | 2917 | e | | 2930 | r | | 2917 | e | Notez que le `` caractère est représenté par un *jeton de caractère* de valeur $$256\times 10 + 32 = 2592$$ mais `\\` est traité comme une commande à caractère unique *jeton de commande* (valeur 4384) qui est calculée à l'aide des formules données ci-dessus : \begin{align\*} \text{curcs} & = 257 + \text{character (ASCII) code}\\\ & = 257 + 32\\\ &=289\\\ \text{command token for} \left<\text{\\\space}\right> & = \text{curcs + 4095}\\\ & = 289+4095\\\ &=4384\\\ \end{align\*} En substance `\mylist={some \TeX{} tokens here}` dit à TeX : veuillez analyser mon fichier d'entrée pour convertir les caractères/commandes suivants en jetons et les sauvegarder pour une utilisation ultérieure. TeX s'exécutera et stockera ces jetons dans un emplacement mémoire auquel vous pouvez accéder en écrivant `\the\mylist`, en demandant à TeX d'insérer une copie des jetons contenus dans le registre de jetons `\mylist`. Les moteurs TeX incluent un certain nombre de commandes primitives qui génèrent et stockent explicitement des listes de jetons — comme `\everyjob`, `\everypar`, `\mark`, et bien d'autres. [Partie 1](/latex/fr/articles-approfondis/19-how-does-expandafter-work-an-introduction-to-tex-tokens.md) [Partie 2](/latex/fr/articles-approfondis/22-how-does-expandafter-work-the-meaning-of-expansion.md) [Partie 3](/latex/fr/articles-approfondis/21-how-does-expandafter-work-tex-uses-temporary-token-lists.md) [Partie 4](/latex/fr/articles-approfondis/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md) [Partie 5](/latex/fr/articles-approfondis/17-how-does-expandafter-work-a-detailed-macro-case-study.md) [Partie 6](/latex/fr/articles-approfondis/18-how-does-expandafter-work-a-detailed-study-of-consecutive-expandafter-commands.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/articles-approfondis/19-how-does-expandafter-work-an-introduction-to-tex-tokens.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.