> 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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.md). # Comment fonctionne \expandafter : des principes de base à l’exploration du code source de 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) ## Introduction Nous avons maintenant abordé les sujets de fond nécessaires pour une exploration complète de `\expandafter`: * les bases des jetons TeX et la manière dont ils sont calculés ; * les principes du processus d’expansion de TeX ; * l’utilisation/la création par TeX de listes temporaires de jetons pendant le traitement du document ; * comment TeX utilise et « jongle » avec plusieurs sources d’entrée (y compris des listes temporaires de jetons). Dans cet article, nous allons rassembler ces sujets/concepts pour expliquer les mécanismes sous-jacents de TeX’s `\expandafter` la commande : en bref, comment cela fonctionne. ## Et donc, pour \expandafter L’idée derrière `\expandafter` consiste à forcer l’expansion d’une commande (jeton) avant que TeX ne le fasse normalement. Étant donné deux jetons, $$\mathrm{T\_1}$$ et $$\mathrm{T\_2}$$ l’action de `\expandafter` $$\mathrm{T\_1T\_2}$$ se traduit, dans le traitement par TeX, par $$\mathrm{T\_1}\text{<}$$l’expansion de $$\mathrm{T\_2}\text{>}$$, où $$\text{<}\dots\text{>}$$ désigne une liste de jetons. TeX développe $$\mathrm{T\_2}$$ à l’avance afin que le jeton $$\mathrm{T\_1}$$ (p. ex. une primitive ou une macro) puisse voir, ou agir sur, les jetons issus de l’expansion de $$\mathrm{T\_2}$$. Si le jeton $$\mathrm{T\_2}$$ représente un élément non extensible tel qu’un caractère non actif ou la plupart des primitives, l’action de `\expandafter` ne change rien : TeX continuerait à traiter les jetons $$\mathrm{T\_1T\_2}$$ de la manière normale. ### Introduction à l’utilisation de \expandafter Si vous n’avez pas utilisé `\expandafter`, voici un exemple utilisant `\uppercase{...}`. Supposons que nous voulions composer le nom de notre principal `.tex` fichier d’entrée, mais en lettres majuscules. Nous pourrions connaître les commandes primitives TeX suivantes : * `\uppercase`: comme son nom l’indique, convertit les jetons de caractères en leur équivalent en majuscules (lorsque celui-ci existe) ; * `\jobname`: comme nous l’avons vu, se développe pour donner le nom du principal `.tex` fichier. Supposons que notre fichier TeX s’appelle `mycode.tex` nous pourrions raisonnablement nous attendre à `\uppercase{\jobname}` de composer `MYCODE`. Mais non, il compose `mycode` en minuscules. Qu’est-ce qui a « mal » tourné ? Si nous écrivons l’utilisation générale de `\uppercase` comme ``` \uppercase{} ``` nous pouvons dire que `\uppercase` parcourt `` et n’agira (ne changera la casse) que sur les *jetons de caractères* qu’il détecte dans le ``: tous les jetons non caractères sont *ignorés* parce que `\uppercase` n’ira pas « regarder à l’intérieur » (développer) les jetons non caractères pour voir ce qu’ils contiennent ou représentent. Comme un jeton est simplement une valeur entière, tout ce que `\uppercase` a à faire est de parcourir la liste de jetons pour vérifier si la valeur numérique de chaque jeton dans `` appartient à l’intervalle des valeurs indiquant un jeton de caractère. Au passage, `\uppercase` ira aussi *changer la casse des caractères actifs* pour créer un caractère actif en majuscules qui, puisqu’il est toujours actif, devra aussi avoir été défini, sinon TeX générera une erreur : `Séquence de contrôle indéfinie`, mais nous nous écartons du sujet... Par exemple, même si nous définissons une macro qui est simplement du texte ``` \def\foo{some lower-case text} ``` alors `\uppercase{\foo}` compose toujours `some lower-case text` et non `SOME LOWER-CASE TEXT` comme nous l’espérerions, simplement parce que l’action de `\uppercase` n’essaie pas de déterminer ce que `\foo` représente : il le voit `\foo` comme un jeton de commande et l’ignore, comme il l’a fait avec `\jobname`. ### Comment pouvons-nous corriger cela ? \expandafter à la rescousse Pour composer une version en majuscules du nom de fichier, nous devons modifier `\uppercase{\jobname}` en forçant TeX à remplacer `\jobname` par son expansion (une séquence de jetons de caractères) *avant* `\uppercase` n’entre en action. Une fois encore, l’expansion est utilisée pour supprimer le `\jobname` jeton (commande) et le remplacer par le résultat de son expansion (une liste de jetons contenant des jetons de caractères). Donc, si nous écrivons ``` \uppercase\expandafter{\jobname} ``` alors cela fonctionne : `MYCODE` serait composé. Ce qui se passe, c’est que TeX commence à traiter `\uppercase` et vérifie immédiatement la présence du caractère obligatoire d’accolade ouvrante (`{`) ; cependant, TeX détecte une `\expandafter` commande qui le conduit à « détourner temporairement son attention » pour traiter `\expandafter{\jobname}`. Si nous comparons `\expandafter` $$\mathrm{T\_1T\_2}$$ avec notre exemple `\expandafter{\jobname}` nous pouvons voir * $$\mathrm{T\_1} =\space$$`{`le jeton * $$\mathrm{T\_2} =\space$$`\jobname`le jeton Où `{`le jeton et `\jobname`le jeton se réfèrent aux valeurs des jetons calculées par TeX — la notation en indice le jeton est utilisée pour nous rappeler que TeX travaille dans le monde des jetons entiers. Écrire `\uppercase\expandafter{\jobname}` fonctionne parce que, en résumé (les détails suivront), `\expandafter` amène TeX à effectuer les tâches suivantes : 1. lire et sauvegarder l’accolade ouvrante `{`le jeton; 2. lire le jeton suivant : `\jobname`le jeton. TeX reconnaît que `\jobname`le jeton représente une commande extensible et l’étend. `\jobname`le jeton est remplacé par son expansion — une série de jetons de caractères ; 3. après avoir développé la `\jobname` commande, TeX remet le `{`$$\_\mathrm{token}$$ « dans l’entrée » et utilise la liste de jetons issue de l’expansion de `\jobname` afin que TeX lise `\uppercase{`le jeton``liste de jetons (caractères)`}`, et cela produit le résultat souhaité. Le diagramme suivant montre comment TeX traite `\uppercase\expandafter{\jobname}`— lisez le graphique de bas en haut pour suivre le déroulement du processus. ![Comment \expandafter fonctionne](/files/9929081f3e862f7db0a16b7dae74120fe49abcd8) Les notes suivantes expliquent les différentes étapes du traitement. 1. TeX commence à traiter `\uppercase` et vérifie la présence du caractère obligatoire d’accolade ouvrante (`{`) mais détecte une `\expandafter` commande. 2. Si nous comparons `\expandafter` $$\mathrm{T\_1T\_2}$$ à notre entrée de `\expandafter{\jobname}` nous pouvons voir $$\mathrm{T\_1} =$$`{`le jeton et $$\mathrm{T\_2} =$$`\jobname`le jeton. Notez qu’ici nous utiliserons l’indice le jeton pour indiquer que TeX traite des valeurs entières de jetons. 3. `\expandafter` lit, puis sauvegarde temporairement, le `{`le jeton en stockant cette valeur entière du jeton dans une variable interne. Plus tard, TeX réinsérera ce jeton dans l’entrée, après avoir traité le `\jobname` commande. 4. `\expandafter` lit le jeton suivant, `\jobname`le jeton, et développe le `\jobname` commande. 5. L’expansion de `\jobname` crée une liste temporaire de jetons qui contient une séquence de jetons de caractères représentant le `.tex` nom du fichier. Notez que tous les jetons de caractères générés par `\jobname` sont calculés à l’aide du code de catégorie 12. 6. Une fois `\jobname` a été développé, TeX réinsère le jeton sauvegardé à l’étape 3 (`{`le jeton) et le remet dans l’entrée. TeX fait cela en créant une autre liste de jetons contenant le *unique* `{`le jeton 7. TeX a maintenant terminé le traitement de `\expandafter`, ce qui produit deux listes de jetons prêtes à être utilisées comme sources d’entrée TeX. TeX revient maintenant au traitement de `\uppercase` mais a configuré son entrée de telle sorte que les deux listes de jetons créées par `\expandafter` deviennent la source de jetons pour `\uppercase`— qui voit maintenant `\uppercase{`le jeton``liste de jetons (caractères)`}`. `\uppercase` voit maintenant une séquence de jetons de caractères et peut produire le résultat souhaité. 8. Après avoir lu tous les jetons de caractères produits par `\jobname`, TeX revient à l’obtention des jetons depuis sa source d’entrée précédente (notre fichier `.tex` ) à partir de laquelle il lira le jeton suivant : la `}` fermante nécessaire pour terminer la liste de jetons à traiter par `\uppercase`. ### \expandafter et les listes de jetons internes Les listes temporaires de jetons sont un *élément vital* du comportement de traitement de `\expandafter`: comprendre l’utilisation et l’existence de ces listes de jetons peut aider à clarifier comment `\expandafter` obtient ses résultats, en particulier lorsqu’on essaie d’écrire ou de comprendre des macros qui utilisent plusieurs `\expandafter` commandes consécutives pour obtenir des formes plus complexes de traitement des jetons : `\expandafter\expandafter\expandafter...` Un autre élément clé du comportement de `\expandafter`, en particulier avec plusieurs `\expandafter` commandes consécutives, est l’utilisation de *la récursivité* (à l’intérieur même du logiciel TeX) — un sujet que nous examinerons plus loin dans cet article. Pour mieux nous aider à comprendre les listes temporaires de jetons, nous allons examiner un autre exemple de `\expandafter`, cette fois avec le `\the` commande. #### \expandafter et les listes de jetons internes : exemple 2 Dans cet exemple, nous verrons comment `\expandafter` peut être utilisé pour influencer les jetons stockés dans un registre de jetons via la `\toks` commande. Voici les primitives TeX que nous utiliserons : * `**\count** *registre*=*nombre*`: une primitive TeX utilisée pour stocker la valeur `*nombre*` dans l’emplacement TeX `*registre*`; * `**\toks** *registre*={*liste de jetons*}`: une primitive TeX utilisée pour stocker `*liste de jetons*` dans l’emplacement du registre de jetons `*registre*`— en sauvegardant une séquence de jetons pour une utilisation ultérieure ; * `**\the** *jeton*`: une primitive TeX extensible qui traite `*jeton*`, bien que les résultats exacts dépendent de la nature du `*jeton*` traité. `\the` a plusieurs utilisations : parmi elles, le fait de composer la valeur stockée dans un paramètre ou une variable TeX (p. ex. un registre). D’autres utilisations de `\the` comprennent l’insertion d’une copie des jetons stockés dans un registre de jetons. Ici, nous utiliserons `\the` pour composer la valeur stockée dans un `\count` registre. Nous commencerons par le code TeX suivant pour stocker la valeur `12345` dans le `\count` registre de TeX `99`: ``` \count99=12345 ``` Si nous voulons composer la valeur stockée dans `\count99` nous pouvons utiliser `\the\count99` (ou `\number\count99`). Ensuite, nous utiliserons la `\toks` commande pour stocker certains jetons dans le registre de jetons `99`: ``` \toks99={\the\count99 } ``` La liste de jetons stockée dans le registre de jetons `99` contiendrait les éléments suivants : | | | | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------ | | **Valeur du jeton TeX** | **Élément représenté** | | 5382 | `\the` | | 7885 | `\count` | | 3129 | `9` (code de caractère 57 avec code de catégorie 12), ce qui donne une valeur de jeton de $$256 \times 12 + 57 = 3129$$ | | 3129 | `9` (code de caractère 57 avec code de catégorie 12), ce qui donne une valeur de jeton de $$256 \times 12 + 57 = 3129$$ | | 2592 | `` (code de caractère 32 avec code de catégorie 10), ce qui donne une valeur de jeton de $$256 \times 10 + 32 = 2592$$ | Notez que la liste de jetons créée par `\toks99` contient *ne* la valeur de données réelle stockée dans `\count99` parce que la `\toks` commande n’effectue pas d’expansion : elle se contente de créer des jetons et de les stocker. Dans notre exemple, `\the` n’est pas développé, donc il ne traite pas `\count99`; ici `\the` est simplement converti en un jeton (valeur 5382) et stocké dans la liste de jetons. Si nous voulons que la `\toks99` liste de jetons contienne des jetons représentant les données stockées dans `\count99` nous aurons besoin d’un moyen de créer ces jetons (de les rendre disponibles) afin que la `\toks` commande puisse y accéder. Et bien sûr `\expandafter` peut faire cela pour nous. Si nous écrivons : ``` \toks99=\expandafter{\the\count99 } ``` l’action/le traitement de la `\toks` commande sera « mis en attente » pendant que `\expandafter` provoque (force) l’expansion de `\the` qui, à son tour, agit sur `\count` pour générer une liste temporaire de jetons contenant des jetons de caractères représentant les données stockées dans `\count99`. Un petit point important est le `` caractère après les chiffres `99`: ce `` caractère sert à terminer le processus de balayage de TeX lorsqu’il recherche une quantité numérique. Ici, l’action de `\expandafter` est très similaire à l’exemple de `\jobname` . 1. Lire et sauvegarder l’accolade ouvrante `{`le jeton. 2. Lire le jeton suivant, `\the`le jeton, qui représente une commande extensible, donc TeX l’étend. `\expandafter` force l’expansion de `\the` qui agit ensuite sur `\count99` pour convertir les données stockées dans `\count` registre de TeX `99` (le nombre 12345) en une liste temporaire de jetons. Cette liste contiendra des jetons de caractères représentant les chiffres `1`, `2`, `3`, `4` et `5`— des jetons de caractères avec code de catégorie 12. 3. Après avoir développé et traité `\the`, TeX remet le `{`le jeton « dans l’entrée » et utilise la liste de jetons issue de `\the\count99` afin que TeX lise `\toks99={`le jeton``liste de jetons (caractères)`}` et cela produit le résultat souhaité. Cette séquence d’événements est résumée dans le diagramme suivant — lisez le graphique de bas en haut pour suivre le déroulement du processus. ![Comment \expandafter fonctionne](/files/1e0337bf036b297c0d7c2c5329d1524f7a324323) 1. TeX commence à traiter `\toks`; il voit le `=` signe facultatif, puis vérifie la présence du caractère obligatoire d’accolade ouvrante (`{`, ou tout caractère avec code de catégorie 1) utilisé pour indiquer le début d’une liste de jetons. Cependant, TeX détecte une `\expandafter` commande et procède à son exécution à la place. 2. Si nous comparons `\expandafter` $$\mathrm{T\_1T\_2}$$ à notre entrée de `\expandafter{\the\count99 }` nous pouvons voir $$\mathrm{T\_1} =$$ `{`le jeton et $$\mathrm{T\_2} =$$ `\thejeton`. 3. `\expandafter` lit, puis sauvegarde temporairement, le `{`le jeton (TeX stocke temporairement cette valeur entière du jeton dans une variable interne). Plus tard, TeX réinsérera ce jeton dans l’entrée, après avoir traité `\the` 4. `\expandafter` lit le jeton suivant, `\the`le jeton et l’étend. 5. L’expansion de `\the` crée une liste temporaire de jetons à partir du traitement de `\count99`— cette liste de jetons contient une séquence de jetons de caractères qui représentent la valeur des données stockée dans le `\count` registre de TeX `99`. 6. Une fois `\the` a été développé, TeX réinsère le jeton sauvegardé à l’étape 3 (`{`le jeton) et remet ce jeton dans l’entrée. TeX fait cela en créant une autre liste de jetons contenant le *unique* le jeton `{`le jeton. 7. TeX a maintenant terminé le traitement de `\expandafter` et a produit deux listes de jetons prêtes à être utilisées comme prochaines sources d’entrée. TeX revient au traitement de `\toks99=` mais maintenant TeX a configuré son entrée de manière à ce que les deux listes de jetons créées par `\expandafter` deviennent la source de jetons pour `\toks`— qui voit maintenant `{`le jeton``liste de jetons (caractères)`}`. `\toks` peuvent maintenant accéder, et stocker, la séquence de 5 jetons de caractères qui représentent la valeur des données (`12345`) stockée dans `\count99`: notre résultat souhaité. 8. Après avoir lu tous les jetons de caractères produits par `\the\count99`, TeX revient à l’obtention des jetons depuis sa source d’entrée précédente (notre fichier `.tex` ) à partir de laquelle il lira le jeton suivant : la `}` nécessaire pour terminer la liste de jetons à enregistrer par `\toks99={...}`. ## Comment \expandafter fonctionne vraiment Dans cette section, nous allons jeter un regard « bas niveau » à l’intérieur même de TeX : explorer le code source/les fonctions de TeX qui implémentent le comportement de `\expandafter`. Les détails sont exprimés en pseudo-code C, mais devraient rester accessibles à toute personne familière avec d’autres langages de programmation. Le diagramme annoté suivant explique comment TeX implémente `\expandafter` dans le cadre d’une fonction plus grande appelée `expand()`— la fonction centrale qui pilote le traitement d’expansion de TeX. Dans la partie responsable de l’implémentation de `\expandafter` nous pouvons voir [*récursif* comportement](https://en.wikipedia.org/wiki/Recursion) où un autre appel à la fonction `expand()` est utilisé pour traiter le deuxième jeton lu, $$\mathrm{T\_2}$$, pour les cas où $$\mathrm{T\_2}$$ est extensible. Bien que ce code apparaisse dans le moteur TeX de Knuth, les principes de base exposés par ce schéma s’appliquent à tous les moteurs TeX. ![Comment \expandafter fonctionne à l’intérieur de TeX](/files/f59826592762f3a04d703599c546752beb411757) La première tâche de `expand()` consiste à déterminer si la commande à développer est une macro ou une primitive, car les macros ont un processus d’expansion spécialisé qui est géré par une fonction appelée `macrocall()`. Si la commande à développer est une primitive, la `expand()` fonction utilise la valeur actuelle du code de commande (stockée dans la variable globale `curcmd`) afin d’identifier quelle primitive particulière doit être traitée. Nous pouvons voir ces détails dans une liste plus complète de `expand()`: ``` void expand(void) { //curcmd est une variable globale if(curcmd != macro) // curcmd < 111 { switch(curcmd) { case \expandafter: // Traiter la commande \expandafter T1T2 { gettoken(); // Lire le jeton T1 t = curtok; // Enregistrer le jeton T1 dans la variable locale t gettoken(); // Lire le jeton T2 if(curcmd > 100) // Le jeton T2 est-il expansible ? expand(); // Oui ! T2 est expansible : // effectuer l'expansion de T2 en // faisant un appel récursif à la fonction expand() else backinput(); // T2 n'est pas expansible : remettre ce jeton // dans l'entrée pour qu'il soit relu (plus tard) curtok = t ; // Restaurer la variable globale curtok à la valeur sauvegardée de T1 backinput() ; // Remettre le jeton T1 dans l'entrée // avant les jetons issus de l'expansion de T2 } break; // Code pour traiter d'autres commandes expansibles case “convert to text” command: // N'importe laquelle de \number, \string, \romannumeral, // \meaning, \fontname, \jobname // Elles partagent la même valeur de curcmd break; case \noexpand: // Supprimer l'expansion du jeton suivant ... break; case \csname: // Fabriquer un nom de séquence de contrôle. ... break; case \the: // Insérer quelques jetons .... break; case “\if... test command” : // Traiter l'un des conditionnels de TeX : // \if, \ifcat, \ifnum, \ifdim,\ifodd, \ifvmode, // \ifhmode, \ifmmode, \ifinner, \ifvoid, // \ifhbox, \ifvbox, \ifx, \ifeof, \iftrue, \iffalse, // \ifcase, \ifdefined, \ifcsname, \iffontchar ... break; case “\fi or \else”: // Mettre fin au conditionnel en cours ... break; // etc. pour toute autre commande primitive expansible prise en charge par // le moteur TeX } }else // Ce n'est pas une primitive expansible : c'est une macro { macrocall() } //... plus de code supprimé } ``` ### L'amour de TeX pour les variables globales Peut-être en raison de son âge et de l'époque à laquelle il a été conçu, le code source de TeX fait un usage intensif des soi-disant [variables globales](https://en.wikipedia.org/wiki/Global_variable)— en fait, il y en a des centaines. Par leur nature même, les variables globales peuvent être modifiées de n'importe où dans le code source de TeX — lequel, pour le TeX de Knuth, est un seul fichier monolithique contenant plus de 25 000 lignes de code et des centaines de fonctions. Comprendre comment TeX fonctionne n'est pas toujours une tâche facile... Pour traiter `\expandafter`, TeX lit des jetons de son entrée courante à l'aide d'une fonction appelée `gettoken()` dont l'action consiste à créer un jeton et à définir la valeur de plusieurs variables globales clés utilisées dans tout le code source de TeX. Deux de ces variables, mises à jour par l'action de `gettoken()`, sont utilisées dans l'implémentation de `\expandafter`: * `curtok`: (jeton courant) la valeur entière du jeton juste lu ; * `curcmd`: (code de commande courant) le code de commande de la commande (ou du caractère) représentée par le jeton `curtok`. Lors du traitement de `\expandafter`$$\mathrm{T\_1T\_2}$$ TeX lit le jeton $$\mathrm{T\_1}$$ et en enregistre temporairement la valeur (un entier) dans une variable locale appelée `t`. TeX lit ensuite $$\mathrm{T\_2}$$ et vérifie si ce jeton représente une commande expansible — en vérifiant si son code de commande (`curcmd`) est > 100. Si c'est le cas, TeX doit faire l'expansion de la commande représentée par $$\mathrm{T\_2}$$ et effectue un autre appel à la fonction `expand()`: c'est un exemple de *la récursivité* parce que la `expand()` la fonction qui s'appelle elle-même. Connaître la nature récursive de l'expansion, en particulier lors de l'utilisation de `\expandafter`, peut aider à comprendre comment plusieurs `\expandafter` commandes — c'est-à-dire, `\expandafter\expandafter\expandafter...` produisent leurs effets. Si le jeton $$\mathrm{T\_2}$$ est expansible, l'expansion a lieu et lorsque l'appel récursif à `expand()` retourne, le code à l'intérieur de l'implémentation de `\expandafter` réinsère le jeton $$\mathrm{T\_1}$$ dans l'entrée. La variable globale `curtok` est réaffectée à la valeur du jeton sauvegardé — stocké dans la variable locale `t`, qui est la valeur du jeton $$\mathrm{T\_1}$$— et un appel est passé à la fonction `backinput().` #### La fonction backinput() Comme son nom l'indique, cette fonction remet un jeton « dans l'entrée ». Pour ce faire, TeX utilise la valeur actuelle de la variable globale `curtok` pour créer une liste de jetons qui contient un seul jeton (dont la valeur entière est fournie par `curtok`). TeX organise également le traitement de son entrée de manière à garantir que cette liste d'un seul jeton sera, au moment approprié, relue par TeX dans le cadre de son traitement ultérieur de l'entrée. Notez bien que le jeton $$\mathrm{T\_1}$$ est réinséré *une fois l'expansion terminée*, ce qui garantit que TeX lira ce jeton réinséré *avant* lorsqu'il lit les jetons résultant de l'expansion de $$\mathrm{T\_2}$$. ### Traitement des macros : la fonction macrocall() Comme indiqué précédemment, toutes les macros, ainsi que certaines commandes primitives, sont expansibles et tout le traitement de l'expansion passe par la `expand()` fonction. Cependant, `expand()` veille à utiliser la `curcmd` valeur (commande courante) pour distinguer les primitives expansibles des macros, car le processus d'expansion des macros est pris en charge par une fonction dédiée appelée `macrocall()`. Les macros nécessitent un processus d'expansion spécialisé, car les arguments de macro et les jetons délimiteurs doivent être recherchés d'une manière très particulière et rigoureuse ; par conséquent, ce processus est délégué à une fonction conçue pour cela : `macrocall()`. #### Expansion de macro vs exécution de macro Macro *expansion* n'est pas le même processus que macro *l'exécution*: l'expansion d'une macro est le processus de pré-exécution que TeX effectue pour préparer la macro *prête à être exécutée*. L'« exécution » d'une macro se produit lorsque TeX lit et traite activement les jetons contenus dans la définition de cette macro (texte de remplacement) et ses arguments (paramètres). #### Expansion de macro Pour développer une macro, TeX vérifie d'abord si la macro prend des arguments ; si c'est le cas, `macrocall()` scanne très soigneusement l'entrée à la recherche de jetons destinés à devenir les arguments de la macro. Ce processus comprend la vérification de l'entrée de l'utilisateur pour tout jeton délimiteur utilisé dans la définition originale de la macro — le modèle de jetons utilisé dans un appel de macro doit correspondre exactement au modèle de jetons contenu dans la définition stockée. Cependant, les jetons utilisés comme délimiteurs sont simplement ignorés par TeX : ils constituent, en fait, une forme de « ponctuation » que TeX utilise pour déterminer les jetons réels destinés à devenir les arguments de la macro — c'est-à-dire les jetons que l'utilisateur souhaite faire traiter par la macro. Pour plus d'informations sur les jetons délimiteurs, voir [Comment fonctionnent réellement les macros TeX](/latex/fr/autres-sujets/22-how-tex-macros-actually-work-part-4.md). Pour chaque paramètre (`#1, #2...#9`) présent dans la définition originale de la macro, TeX analyse l'appel de macro réel afin d'identifier quels jetons fournis par l'utilisateur sont destinés à chaque paramètre (c'est-à-dire forment les arguments de la macro). Ce processus produit une ou plusieurs mini-listes de jetons : une pour chaque argument de macro. Après la détection éventuelle des arguments de macro, et une fois leurs listes de jetons préparées, TeX récupère la définition de la macro (texte de remplacement) stockée dans sa mémoire et organise le traitement de son entrée de sorte que, chaque fois que TeX sera prêt à lire/traiter davantage de jetons, il les lira depuis le texte de remplacement de la macro, exécutant ainsi la macro. Au moment approprié, pendant l'exécution de la macro, les listes de jetons représentant les arguments de la macro seront insérées à l'emplacement correct dans le texte de remplacement de la macro. Une fois encore, l'expansion d'une commande de macro signifie *supprimer* cette commande de macro (jeton) de l'entrée et *remplacer* la par la liste de jetons stockée comme texte de remplacement de la macro. Pour un examen approfondi du traitement des macros de TeX, voir la série d'articles en six parties [Comment fonctionnent réellement les macros TeX ?](/latex/fr/autres-sujets/01-a-six-part-series-how-do-tex-macros-actually-work.md) [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/20-how-does-expandafter-work-from-basic-principles-to-exploring-tex-s-source-code.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.