> 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/22-how-tex-macros-actually-work-part-4.md). # Comment fonctionnent réellement les macros TeX : partie 4 [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) ## Introduction et aperçu Dans les parties 1 à 3, nous avons approfondi certains détails de fond de bas niveau afin de préparer la compréhension du fonctionnement des macros TeX. Dans cet article, nous allons « reprendre notre souffle » pour passer en revue certains principes pratiques de base des macros TeX en vue d’un autre approfondissement dans les parties 5 et 6. Tout au long de cet article, nous allons montrer des macros d’exemple définies à l’aide de la commande primitive TeX `\def` : nous n’utiliserons pas la commande LaTeX, peut-être plus familière, `\newcommand`. Il y a une très bonne raison à cela : notre objectif est de comprendre les principes fondamentaux qui sous-tendent le comportement des macros TeX, mais pour ce faire nous devons utiliser les commandes de base *intégrées dans* du logiciel TeX. Les commandes LaTeX, telles que `\newcommand`, sont elles-mêmes des macros : des commandes au comportement programmé spécifique qui sont, en fin de compte, construites à partir de couches de commandes primitives TeX de niveau inférieur. Pour mieux comprendre le comportement fondamental de TeX, nous devons utiliser les primitives TeX, pas les macros LaTeX. ### Où allons-nous ? En substance, nous travaillons à une explication des macros comme forme spécialisée de liste de jetons : lorsque vous demandez à TeX de définir une macro, il crée une séquence de jetons (une liste de jetons) et la stocke en mémoire, associée à un nom que vous définissez. Dans les parties 5 et 6, nous examinerons les listes de jetons des macros plus en détail, mais si vous préférez quitter cet article pour lire des informations de fond, vous pouvez les trouver dans [Qu’est-ce qu’une liste de jetons TeX ?](/latex/fr/articles-approfondis/54-what-is-a-tex-token-list.md) Les listes de jetons des macros, ainsi que leurs paramètres, comportent quelques subtilités supplémentaires que nous allons examiner en détail — et en utilisant de nombreux exemples. Pour mieux comprendre le ou les comportements de traitement des macros de TeX, il y a vraiment un facteur clé à retenir : TeX ne pense aux caractères qu’au tout premier stade du traitement de l’entrée : à partir de là, ce ne sont plus que des jetons ! Dans cet article et les suivants de cette série, nous explorerons le rôle que jouent les jetons dans les macros TeX. ## Les quatre parties d’une macro ### Rappel : paramètres de macro et arguments de macro Avant de commencer, il vaut la peine de nous rappeler la différence entre les *paramètres* et les *arguments*, car nous utiliserons ces deux termes tout au long de cet article. Supposons que vous définissiez une macro \foo ``` \def\foo#1#2{Ceci est #1, ceci est #2} ``` Les constructions (jetons) `#1`, `#2` (jusqu’à `#9`) sont appelées les *paramètres*: imaginez-les comme des « espaces réservés » pour les données réelles que vous utiliserez lorsque vous appellerez la macro : ``` \foo{alpha}{beta} ``` Ici, `alpha` et `beta` sont les *arguments* utilisés avec cet appel de \foo : les arguments d’une macro sont les valeurs réelles injectées dans les espaces réservés des paramètres (`#1`, `#2`... `#9`) utilisés lorsque vous avez défini la macro. ### Définition de macro : comporte 4 éléments Nous commencerons par ce qui ressemble peut-être à une définition un peu formelle d’une macro, mais elle fournit un cadre utile pour les discussions ultérieures. Toute définition de macro se compose de 4 parties : ``` {} ``` où : * ``: l’une de `\def`, `\edef`, `\gdef` ou `\xdef`; * ``: le nom donné à votre commande de macro, comme `\foo`; * ``: cela peut être absent, mais, s’il y en a un, il s’agit d’une série de *jetons* qui apparaissent avant le `` de la macro. Le `` peut contenir des paramètres de macro (`#1`, `#2`... `#9`) et d’autres types de jetons. En substance, et comme nous le verrons en détail, le `` fournit une sorte de *modèle de jetons* que TeX utilise pour déterminer quels jetons l’utilisateur souhaite utiliser comme arguments de la macro : lorsque vous appelez une macro, TeX alimente les *argument* jetons dans votre `` (qui est aussi une liste de jetons) ; * `{}`: c’est le corps réel de votre macro : c’est une série de jetons dans laquelle les *arguments* sont « injectés » lorsque la macro est traitée (développée). Les arguments sont insérés aux emplacements indiqués par les paramètres de macro utilisés dans la définition originale. **REMARQUE**: Tout au long de la discussion, nous supposons que `` sera suivi d’un caractère espace de code de catégorie 10 pour agir comme délimiteur afin de terminer le ``. Nous *n’avons pas* montré explicitement ce caractère espace dans notre texte/discussion, mais nous supposons qu’il est là. À strictement parler, nous devrions le représenter un peu comme ceci : ``` {} ``` Cependant, nous omettrons l’inclusion explicite d’un `` caractère et supposerons implicitement sa présence. #### Notes sur {} Nous avons montré l’utilisation de deux accolades : `{` et `}` qui entourent (délimitent) le corps réel de votre ``. Cependant, l’utilisation de `{` et `}` n’est qu’une convention adoptée, car ce que TeX attend en réalité, c’est que le texte de votre macro `` s’ouvre avec un caractère de code de catégorie 1 (« Début d’un groupe ») et se ferme avec un caractère de code de catégorie 2 (« Fin d’un groupe »). Par convention, ce sont les caractères `{` et `}` respectivement. Cependant, vous pouvez, si vous le souhaitez, attribuer n’importe quelle paire de caractères pour faire cela. Par exemple ``` \catcode`\(=1 \catcode`\)=2 ``` Vous pouvez maintenant définir et utiliser des macros comme ceci : ``` \def\foo #1(Hello, #1) \foo(World!) ``` Et vous pouvez toujours utiliser `{` et `}` car nous n’avons pas changé leurs codes de catégorie — plusieurs caractères peuvent, et ont effectivement, le même code de catégorie, donc vous pourriez continuer à définir des macros de la manière habituelle : ``` \def\foo #1{Bonjour, #1} \foo{World!} ``` ### et {} Les composants de la définition d’une macro qui sont les plus pertinents pour notre discussion sont `` et `{}`. Lorsque vous définissez une macro, le `` est, en pratique, un modèle de jetons strict qui définit la manière dont la macro doit être utilisée. Comme indiqué, `` peut être vide, par exemple, `\def\foo{Some text}` où rien n’apparaît entre le nom de votre commande (`\foo`) et l’accolade ouvrante `{` qui, ici, signale le début du ``. **Remarque**: certains lecteurs connaîtront peut-être le mécanisme « hashquote » de TeX (`#{`) mais nous n’y toucherons pas ici. ### et les délimiteurs de macro Cet article particulier n’est pas conçu comme une revue exhaustive de l’écriture des macros, mais il vaut la peine de faire un bref rappel, avec quelques exemples, montrant que le `` peut devenir complexe, car TeX permet `` de contenir : * **des paramètres de macro**: (`#1`, `#2`,... `#9`) qui servent d’« espaces réservés » pour les valeurs que l’utilisateur fournira lorsqu’il exécutera la macro — les *arguments*; * **tokens délimiteurs**: des jetons arbitraires, intercalés dans/autour des jetons de paramètres, et utilisés pour spécifier la frontière entre les paramètres de macro. Vous pouvez voir ces délimiteurs comme formant une sorte de « ponctuation » qui rend le `` un « modèle de jetons » que vous devrez suivre lorsque vous utilisez la macro. Les jetons délimiteurs ne sont pas composés typographiquement. Alors, qu’est-ce que cela signifie réellement — regardons quelques exemples. Le `` se place entre le nom de la macro et l’accolade gauche `{` de la définition de la macro. #### Délimiteurs : exemple 1 Supposons que nous définissions une macro de base `\foo` comme suit : ``` \def\foo ABC{bonjour, ici} ``` * `` = `ABC` * Il n’y a aucun jeton de paramètre (`#1`, `#2`,... `#9`) * Les délimiteurs sont les *trois jetons de caractère* `ABC` mais, dans cet exemple, ils sont quelque peu superflus et ne servent que d’exemple. Les trois jetons de caractère `ABC` sont traités comme des délimiteurs : non pas quelque chose à composer typographiquement, mais de la « ponctuation » dont la présence est attendue lorsque la macro est appelée — lorsque vous utilisez la macro `\foo` vous devez fournir les mêmes délimiteurs que ceux présents lors de sa définition. Si vous tapez `\foo ABC` dans votre texte, cela composera `bonjour, ici`— les jetons de caractère `ABC` ne sont pas composés typographiquement, mais TeX a vérifié, très soigneusement, qu’ils étaient présents dans votre invocation (appel) de `\foo`. TeX cherche ces délimiteurs (« ponctuation ») et les supprime (les absorbe), comme vous pouvez le voir dans la capture d’écran Overleaf suivante : `ABC` n’est pas composé typographiquement : ![Overleaf exécutant une macro TeX](/files/6fa36050c5fe4ac04739af6e1f4db9ec66744ceb) Si vous essayez d’utiliser `\foo` sans les `ABC` délimiteurs, TeX se plaindra `L’utilisation de \foo ne correspond pas à sa définition.`: ![Affichage d’une erreur TeX sur Overleaf](/files/d78376727f19979c34cecfd75c8ce34a46a97d17) Dans l’exemple ci-dessus, après avoir détecté `\foo` TeX s’attend à voir les trois jetons de caractère `ABC` mais ce n’est pas le cas : il voit le jeton de caractère pour `w` et détecte immédiatement que quelque chose ne va pas. #### Délimiteurs : exemple 2 Fait intéressant, et peut-être surprenant, les délimiteurs peuvent être des jetons de commande arbitraires — y compris des commandes qui n’ont *même pas été définies*. Par exemple, nous pourrions définir `\foo` comme : ``` \def\foo A\bob B\anne{Bonjour \TeX{}} ``` * `` = `A\bob B\anne` * Il n’y a aucun jeton de paramètre (`#1`, `#2`,... `#9`) * Les délimiteurs sont les jetons `A\bob B\anne` mais encore une fois, dans cet exemple, ils sont superflus et ne servent qu’à des fins de discussion. Notez que `\bob` et `\anne` sont des commandes fictives qui n’étaient *pas définies*— et il n’est pas nécessaire qu’elles le soient. Lorsque vous appelez une macro, TeX vérifie (parcourt) `` qui est présent *dans votre appel de macro* et le compare, jeton par jeton, avec la version « modèle de jetons » *stockée en mémoire*— celle créée au moment où la macro a été définie. TeX parcourt les *utilisés dans votre appel de macro* et convertit simplement toutes les commandes qu’il y trouve en leur valeur numérique de jeton : il n’essaie pas d’exécuter ces commandes, donc cela n’a pas d’importance que `\bob` et `\anne` n’aient jamais été définies. TeX utilise simplement le modèle de jetons stocké en mémoire comme guide lui permettant de déterminer quels jetons dans le `` de votre appel de macro sont les arguments réels à injecter dans les ``. Comme vous pouvez le voir dans l’extrait d’écran Overleaf suivant, aucun des jetons de caractère (`A` et `B`) dans `A\bob B\anne` ) n’a été composé typographiquement et nos commandes indéfinies `\bob` et `\anne` n’ont causé aucun problème. Tous ces jetons ont été *absorbés* par TeX lorsqu’il a fait correspondre votre utilisation de `\foo` avec la définition (modèle de jetons) de `\foo` (une liste de jetons) stockée en mémoire. ![Overleaf exécutant une macro TeX](/files/a575649145cef46cc3cdd51ab29e9e203c6b4a9f) #### Délimiteurs : exemple 3 Vous pouvez entrelacer divers délimiteurs (jetons de caractère, jetons de commande) avec des paramètres de macro, comme dans cet exemple : ``` \def\foo A\bob#1B\anne#2\jane#3bye!{Bonjour de \TeX{} à \#1=#1, \#2=#2 et \#3=#3} ``` * `` = `A\bob#1B\anne#2\jane#3bye!` * Il y a 3 jetons de paramètre : `#1`, `#2`, `#3` * Cette fois, les paramètres (`#1`, `#2`, `#3`) sont délimités par une combinaison de jetons : `A\bob#1B\anne#2\jane#3bye!` Ici, vous avez en pratique fourni à TeX un modèle qu’il essaiera très soigneusement de faire correspondre, et auquel il s’attendra, lorsque vous appellerez `\foo`: il parcourra votre appel de macro, *jeton par jeton*, et s’attendra à faire correspondre (à trouver) : * les deux jetons `A` et `\bob` avant `#1` * les deux jetons `B` et `\anne` avant `#2` * le jeton `\jane` avant le paramètre `#3` et le *quatre jetons de caractère* `b`, `et`,`e` et `!` après `#3`. **Souvenez-vous**: TeX pense en jetons donc `bye!` est *quatre jetons de caractère*. Il y a deux façons d’utiliser cette macro — nous pourrions mettre entre accolades tous les arguments composés de plusieurs jetons afin de fournir un groupe : ``` \foo A\bob{This}B\anne{That}\jane{Other}bye! ``` Cependant, cela *n’est pas nécessaire* car la définition de notre macro comporte des délimiteurs qui fournissent un modèle de jetons. TeX peut utiliser ce modèle pour repérer les jetons de chaque argument parmi des jetons qui sont purement des délimiteurs. Nous pouvons utiliser notre macro ainsi : ``` \foo A\bob ThisB\anne That\jane Otherbye! ``` et TeX peut repérer les arguments pour produire le même résultat qu’avec des groupes `{...}`: ![Overleaf exécutant une macro TeX à l’aide de délimiteurs](/files/45ce8742e614193487b1554d8135cf5151ada372) Remarquez comment TeX a pu détecter, précisément, quels jetons correspondaient aux paramètres `#1` et `#3`: ![Overleaf exécutant une macro TeX à l’aide de délimiteurs](/files/21eed30a6e3804a4bd74910b4d3de81160f36c88) #### Délimiteurs : exemple 4 (tout est une question de jetons, pas de caractères !) Voici un bref exemple pour montrer que, lorsqu’on travaille avec des macros, il est important de se rappeler que nous sommes vraiment dans le monde des *jetons* et **ne** *caractères*… Nous allons définir la petite macro suivante, où A et B sont des caractères jouant le rôle de délimiteurs et ont tous deux le code de catégorie 11. Cela fonctionne sans problème : ``` \documentclass{article} \begin{document} \def\foo A#1B{Bonjour, #1} \foo AGrahamB \end{document} ``` et compose `Bonjour, Graham`. Cependant, si vous changez le code de catégorie de A ou de B pour quelque chose d’autre que 11, l’appel de macro échouera. Supposons que nous changions le code de catégorie de B à 12, en utilisant ``\catcode`B=12`` et essayons d’appeler à nouveau la macro, comme précédemment : ``` \documentclass{article} \begin{document} \def\foo A#1B{Bonjour, #1} \foo AGrahamB % Cela fonctionne \catcode`\B=12\relax \foo AGrahamB \end{document} ``` Cela échoue avec une erreur plutôt déroutante : ``` Argument en fuite ? GrahamB \end {document} ! Le fichier s’est terminé pendant l’analyse de l’utilisation de \foo. \par <*> main.tex Je soupçonne que vous avez oublié un `}', ce qui me pousse à lire au-delà de l’endroit où vous vouliez que je m’arrête. Je vais essayer de récupérer ; mais si l’erreur est grave, vous feriez mieux de taper maintenant `E' ou `X' et de corriger votre fichier. ! Arrêt d’urgence. <*> main.tex *** (travail interrompu, aucun \end valide trouvé) ``` ![Capture d’écran Overleaf montrant une erreur de macro TeX](/files/f66b68b1d7a4d6e535156994f195b3277aaf5475) Malheureusement, la suggestion par défaut de TeX, à savoir ``Je soupçonne que vous avez oublié un `}'`` est **incorrecte**, n’est pas causée par une accolade manquante (`}`). #### Que s’est-il passé ? TeX essaie de faire correspondre l’ `\foo` macro *appel* avec le `\foo` macro *définition* modèle de jetons qu’il a stocké en mémoire. Lorsque vous appelez une macro qui a besoin d’un ou plusieurs arguments, TeX doit examiner (parcourir) votre utilisation de la macro pour déterminer les *arguments* que vous fournissez à cette macro. Ici, TeX s’attend à ce que l’argument soit encadré par un A (code de catégorie 11) et un B (code de catégorie 11). Souvenez-vous : TeX pense en *jetons*, **ne** *caractères*. Les valeurs de jeton pour A et B, $$\mathrm{T\_A}$$ et $$\mathrm{T\_B}$$ respectivement, sont : $$\mathrm{T\_A = 256 \times 11 + 65 = 2881}$$ $$\mathrm{T\_B = 256 \times 11 + 66 =2882}$$ Cependant, au fur et à mesure que TeX poursuit sa recherche, il voit le B *mais* à présent, il a le code de catégorie 12 et cela donne une valeur de jeton différente : $$\mathrm{T'\_B= 256 \times 12 + 66 =3138}$$ Dans l' `\foo` dans la définition de la macro, la valeur de jeton pour B (utilisée comme délimiteur) était 2882, mais TeX voit maintenant une valeur de jeton de 3138 : il pense qu’il ne s’agit que d’un jeton supplémentaire destiné à être utilisé dans l’ *argument* fourni à `\foo`. Du point de vue de TeX, le dernier jeton de l’argument n’a pas encore été trouvé, alors il va chercher un autre jeton pour trouver un B avec le code de catégorie 11. C’est à ce moment-là, et pour cette raison, que la macro échoue : dans sa tentative de trouver l’argument, TeX « dépasse » et commence à lire des jetons que vous n’aviez pas l’intention de voir faire partie de l’argument pour l’ `\foo` appel de macro. Ce qui se passe ensuite dépend des jetons que TeX découvre après le B — ils déclencheront diverses `Argument en fuite ?` erreurs. Dans notre exemple, TeX dépasse et consomme le flux de jetons `\end {document}` et atteint rapidement la fin du fichier, d’où le message d’erreur : ``` ! Le fichier s’est terminé pendant l’analyse de l’utilisation de \foo ``` ## Partie 5 Comme nous l’avons vu ci-dessus, la `` section de la définition de notre macro peut aller d’une extrême simplicité à un mélange complexe de paramètres de macro entrecoupés de jetons de caractère et de jetons de commande jouant le rôle de délimiteurs. TeX est capable de traiter les diverses combinaisons de jetons présentes dans `` pour extraire les arguments fournis à une macro — et détecter quand nous essayons d’utiliser une macro de manière incorrecte. La manière dont il fait cela sera le sujet du prochain article de la série. [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/22-how-tex-macros-actually-work-part-4.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.