Debian Codegraph @

texmf-dist/doc/generic/tokstools/tokstools-fr.tex

raw
1 % !TeX TS-program = lualatex
2 % !TeX encoding = UTF-8
3 % Ceci est la documentation en français du package "toktools"
4 \documentclass[french,a4paper,10pt]{article}
5 \usepackage[margin=2cm]{geometry}
6 \usepackage[bottom]{footmisc}
7 \usepackage[libertine]{newtxmath}
8 \usepackage{libertineRoman,enumitem,babel,xspace,tokstools,hyperref,array,footnotehyper,multicol}
9 \makesavenoteenv{tabular}
10 \RequirePackage[most]{tcolorbox}
11 \tcbuselibrary{listings}
12 \usepackage[scaled=0.8]{GoMono}
13 \def\tktl{\texttt\tktlname\xspace}
14
15 \catcode`\_11
16 \long\def\def_active#1#2{%
17 \catcode`#1=13
18 \begingroup
19 \lccode`\~`#1
20 \lowercase{\endgroup\long\def~{#2}}%
21 }
22
23 %%%%%%%%%%%%% la macro \tktlcode %%%%%%%%%%%%%
24 \def\nolig_list{\do\`\do\<\do\>\do\,\do\'\do\-}
25 \def\do_noligs#1{%
26 \catcode`#1\active
27 \begingroup
28 \lccode`\~`#1\relax
29 \lowercase{\endgroup\def~{\leavevmode\kern0pt \char`#1\relax}}%
30 }
31 \def\no_ligs{\let\do\do_noligs \nolig_list}
32 \newif\ifspecialcode
33 \specialcodefalse
34 \def\specialcode{\specialcodetrue}
35 \def\tktlcode{\expandafter\tktlcode_i\string}
36 \def\tktlcode_i#1{%
37 \begingroup
38 \nobreak\smallbreak
39 \parindent0pt
40 \parskip=0pt
41 \leftskip2.5em
42 \rightskip0pt
43 \nonfrenchspacing
44 \no_ligs
45 \def\do##1{\catcode`##1=12\relax}\dospecials
46 \ifspecialcode\else
47 \def_active\<{\begingroup$\langle$\ttfamily\itshape}%
48 \def_active\>{$\rangle$\endgroup}%
49 \def_active\&{\string}%
50 \def_active\_{\tktlsubscript}%
51 \fi
52 \ttfamily
53 \def_active\^^I{\space\space\space\space}%
54 \def_active\^^M{\par\noindent}%
55 \def_active\ {\space}%
56 \catcode`#1=12
57 \def\tktlcode_ii##1#1{##1\par\endgroup\specialcodefalse}%
58 \tktlcode_ii
59 }
60 \catcode`\_8
61 \def\tktlsubscript#1{$_{#1}$}
62
63 \makeatletter
64 \let\Verb\verb
65 \begingroup
66 \catcode`\<13 \catcode`\>13
67 \gdef\verb{\relax\ifmmode\hbox\else\leavevmode\null\fi
68 \bgroup
69 \verb@eol@error \let\do\@makeother \dospecials
70 \verbatim@font\@noligs
71 \catcode`\<13 \catcode`\>13 \def<{\begingroup$\langle$\itshape}\def>{\/$\rangle$\endgroup}%
72 \@ifstar\@sverb\@verb}
73 \endgroup
74 \def\longfrdate@i#1/#2/#3\@nil{\number#3\relax\space \ifcase#2 \or janvier\or février\or mars\or avril\or mai\or juin\or juillet\or aout\or septembre\or octobre\or novembre\or décembre\fi\space#1}
75 \edef\longfrdate{\expandafter\longfrdate@i\tktldate\@nil}
76 \def\<#1>{$\langle${\ttfamily\itshape#1\/}$\rangle$}
77 \makeatother
78 \newtcblisting{doclatex}{
79 boxrule=.5pt,
80 boxsep=0pt,
81 top=5pt,
82 left=5pt,
83 right=5pt,
84 bottom=5pt,
85 skin=bicolor,
86 colbacklower = white,
87 colback = black!15,
88 listing options={%
89 style=tcblatex,
90 language={TeX},
91 showspaces=false,
92 showstringspaces=false,
93 commentstyle=\itshape\color{gray!80!white},
94 basicstyle=\ttfamily\footnotesize
95 }
96 }
97
98 \begin{document}
99 \parindent=0pt
100 \thispagestyle{empty}
101 \begin{titlepage}
102 \begingroup
103 \centering
104 \null\vskip.25\vsize
105 {\large\bfseries L'extension pour \TeX{} et \LaTeX\par \Huge \tktlname\par}
106 \bigbreak
107 v \tktlver
108 \smallbreak
109 \longfrdate
110 \vskip1.5cm
111 Christian \bsc{Tellechea}\par
112 \texttt{[email protected]}\par
113 \endgroup
114 \vskip2cm
115 \leftskip=.2\linewidth \rightskip=.2\linewidth \small
116 Cette extension pour \TeX{} ou \LaTeX{} met des outils basés sur des grammaires de type PEG (Parsing Expression Grammars) pour manipuler des tokens. Dans un ensemble arbitraire de tokens équilibrés en accolades, il est possible d'établir des règles de correspondance pour tester si une correspondance existe, de les compter, d'effectuer des remplacements, de capturer des tokens, etc.
117 \end{titlepage}
118 \parindent0pt \pagestyle{plain}
119 \tableofcontents
120 \parskip\medskipamount
121 \newpage
122
123 \section{Présentation}
124 L'extension \tktl fonctionne avec tout moteur. Elle n'est pas limité à \LaTeX{} seulement, comme l'est malheureusement le package \texttt{pegmatch}, et pour l'utiliser, il faut écrire
125 \begin{itemize}
126 \item \verb|\input tokstools.tex| sous (pdf)(Xe)(lua)(op)\TeX\ (la syntaxe \verb|\input{tokstools.tex}| est également admise);
127 \item \verb|\usepackage{tokstools}| sous (pdf)(Xe)(lua)\LaTeX.
128 \end{itemize}
129
130 Ce package ne requiert que le package \href{https://ctan.org/pkg/simplekv}{simplekv} qui sera chargé si ça n'a pas été le cas.
131
132 \textit{Avertissement} : dans ce manuel, une (grande) liberté sera prise quant aux termes employés et des mots anglais seront très fréquemment utilisés, autant par commodité et habitude que par pure flemme de rédiger des tournures 100~\% françaises plus lourdes ou alambiquées.
133 \begin{center}
134 \renewcommand\arraystretch{1.15}
135 \begin{tabular}{|p{5cm}|p{7cm}|}\hline
136 \bfseries mot/expression & \bfseries en français \\\hline
137 token & unité syntaxique \\\hline
138 match & correspondance \\\hline
139 les tokens ayant matché & les tokens ayant produit une correspondance \\\hline
140 catcode & code de catégorie (est un entier de 0 à 16) \\\hline
141 charcode & code de caractère (est un entier) \\\hline
142 liste csv & liste d'éléments séparés par des virgules \\\hline
143 package & extension ou paquet \\\hline
144 \end{tabular}
145 \end{center}
146
147 \subsection{Nouveau dans la version 0.2}
148 \paragraph{Macro \texttt{\textbackslash pegreplace}}
149 La macro \verb|\pegreplace| change de syntaxe tout en offrant davantage de fonctionnalités, voir page~\pageref{pegreplace}. Ce changement casse malheureusement la syntaxe de la version 0.1, j'en suis sincèrement désolé et présente mes excuses aux utilisateurs de \tktl pour ce désagrément.
150
151 \paragraph{Macro \texttt{\textbackslash printtoks}}
152 La macro \verb|\printtoks| a désormais la possibilité, selon la valeur de la nouvelle clé \verb|mode|, de diriger les informations des tokens vers le fichier log, voir page~\pageref{printtoks}.
153
154 \paragraph{Validité des directives d'assignation}
155 Désormais, aucune vérification de validité n'est effectuée pour les « directives d'assignation » passées par la clé \verb|assign| et similaires. L'utilisateur doit donc faire le choix éclairé entre :
156 \begin{itemize}
157 \item \verb|assign={}| qui est une directive vide pour diriger le résultat dans le flux de lecture de \TeX{} en vue de l'afficher;
158 \item \verb|assign=\def<macro>| pour que le résultat soit assigné à la \<macro>;
159 \item \verb|assign=<registre de tokens>| pour assigner le résultat à un registre de token, ce qui s'avère nécessaire lorsque y figurent des tokens de catcode 6 (\verb|#|) pour désigner des arguments.
160 \end{itemize}
161
162 \subsection{Tokens, charcode, catcode, moteurs}
163 Le package \tktl agit sur des ensembles de tokens (ou chaines de tokens). Les tokens sont la plus petite unité du code source manipulée par \TeX.
164
165 L'utilisateur doit avoir conscience que la notion de tokens dépend du type de moteur utilisé. Ce n'est \emph{que} pour les moteurs 8~bits, tels que pdf\LaTeX{} par exemple, que \hbox{1 token${}={}$1 octet}. À titre d'exemple, le caractère «\verb|€|» est vu
166 \begin{itemize}
167 \item par pdf\LaTeX{} comme 3 tokens dont les charcodes sont 226; 130 et 172 et les catcodes sont tous égaux à 13 ;
168 \item par lua\LaTeX{} comme 1 seul token de charcode 8364 et de catcode 12.
169 \end{itemize}
170
171 Cette différence doit être prise en compte et peut être source d'erreurs plus ou moins compréhensibles lorsqu'on manipule des caractères UTF8 sur un moteur 8~bits.
172
173 Ce manuel a été compilé avec lua\LaTeX, et donc des tokens ayant des charcodes supérieurs à 255 peuvent exister.
174
175 Quelles que soient les macros mises à disposition par \tktl, elles décomposent toujours leur argument contenant les tokens, noté \<tokens>, en liste de tokens, chacun possédant un charcode et un catcode. Les catcodes visibles par \tktl sont listés dans le tableau ci-dessous, avec pour chacun les tokens les plus courant de charcode inférieur à 255 qui possèdent ces catcodes par défaut.
176 \begin{center}
177 \renewcommand\arraystretch{1.15}
178 \begin{tabular}{>{\leftskip0ptplus1fill \rightskip\leftskip}p{1.25cm}p{5.5cm}p{6.5cm}}\hline
179 Catcode & Description & Tokens\\\hline
180 1 & début de groupe & \verb|{|\\
181 2 & fin de groupe & \verb|}|\\
182 3 & délimiteur de mode mathématique & \verb|$|\\
183 4 & tabulation d'alignement & \verb|&|\\
184 6 & caractère de paramètre & \verb|#|\\
185 7 & exposant & \verb|^|\\
186 8 & indice & \verb|_|\\
187 10 & espace & \Verb*| | et \itshape HT\\
188 11 & lettres & \verb|a-z| et \verb|A-Z|\\
189 12 & autres caractères & chiffres (\verb|0-9|)\par
190 signes de ponctuation (\verb|: . ; , ? ! ' "|)\par
191 signes mathématiques (\Verb|+ - * / = < >|)\par
192 autres signes (\verb/[ ] ( ) | @ `/)\\
193 13 & caractère actif & \verb|~|\\
194 16 & séquence ou caractère de contrôle & \verb|\<lettres>| ou \verb|\<caractère>| \\
195 \hline
196 \end{tabular}
197 \end{center}
198 Aucune des macros mises à disposition par \tktl n'est développable. Si l'on souhaite que le résultat de ces macros ou bien des captures soient contenus dans des macros purement développables, il faut utiliser des consignes d'assignation qui seront définies dans ce manuel.
199
200 \subsection{Notations}
201 Ce qui est appelé « marqueur » dans ce manuel est une séquence (ou caractère) de contrôle qui agit comme un repère afin d'être reconnue dans un argument, mais qui n'est pas modifiée par \tktl et dont la signification n'a aucune importance.
202
203 Dans tout le manuel :
204 \begin{itemize}
205 \item \<tokens> désigne un ensemble de tokens\footnote{La primitive \texttt{\textbackslash par} peut se trouver dans \<tokens>.} équilibrés en tokens de catcode 1 et 2 (accolades ouvrantes et fermantes) qui se trouve comme argument des macros ou des marqueurs en charge de traiter ces tokens;
206 \item \<1-motif> représente un motif unique, c'est à dire constitué d'un marqueur avec son éventuel argument, précédé d'un prédicat optionnel et suivi d'une spécification optionnelle de répétition;
207 \item \<motifs> représente un seul \<1-motif> ou une combinaison de plusieurs \<1-motif> obtenue avec l'opérateur de concaténation «\verb|:|» et l'opérateur de choix ordonné «\verb/|/» (seulement l'opérateur «\verb/|/» pour \verb|\toksdo| et \verb|\tokscount|);
208 \item \verb|{<motifs>}| est un groupement qui admet un prédicat et une directive de répétition optionnels et qui se comporte comme un \<1-motif>.
209 \end{itemize}
210
211 \subsection{Informations sur les tokens avec {\ttfamily\textbackslash printtoks}}\label{printtoks}
212 La macro
213 \tktlcode|\printtoks[<clés>=<valeurs>]{<tokens>}|
214 permet d'afficher les tokens avec, au-dessous de chacun, son charcode et son catcode. Si un token est une séquence de contrôle ou un caractère de contrôle, aucun charcode n'est affiché.
215
216 \begin{doclatex}
217 \catcode`\!=6 % "!" est similaire à "#"
218 \printtoks[code=\ttfamily]{\def\foo#1!2#3{\hbox to 1cm{\hss$!1^#2_!3$\hss}}}
219 \medbreak
220 \printtoks[code=\ttfamily]{eéė€}
221 \end{doclatex}
222
223 Les \<clés> disponibles sont :
224 \begin{center}
225 \renewcommand\arraystretch{1.25}
226 \begin{tabular}{>\ttfamily p{3.5cm}>\ttfamily p{2.5cm}p{8cm}}\hline
227 \rmfamily Clé & \rmfamily Valeur par défaut & Description\\\hline
228 expand arg & 0 & nombre de développements que doit subir l'argument contenant les \<tokens> avant d'être pris en compte\\
229 code & \<vide> & code exécuté avant d'afficher un token\\
230 intertoks & 0.33em & espace horizontale entre chaque token, insérée par la primitive \verb|\hskip|\\
231 printcharcode & true & affiche ou pas le charcode\\
232 printcatcode & true & affiche ou pas le catcode\\
233 hexcharcode & false & affiche le charcode en base 16 si \verb|true| et en base 10 sinon\\
234 baselinecoeff & 0.8 & coefficient d'espacement vertical\\
235 vlines & true & affiche ou pas les lignes verticales entre chaque token\\
236 boxed & true & met le tout dans une \verb|\hbox| si \verb|true|, ce qui rend le tout insécable\\
237 mode & 0 & si 1 ou 2, dirige les informations sur les tokens vers le fichiers log\\\hline
238 \end{tabular}
239 \end{center}
240
241 Lorsque la clé \verb|mode| vaut 1, les informations sur chaque token sont aussi dirigées vers le fichier log. Lorsque cette valeur est 2, c'est uniquement vers le fichier log et aucun affichage dans le pdf n'est produit.
242
243 Ainsi, le code
244 \specialcode\tktlcode|\def\foo#1{$#1$}
245 \catcode`\!=6 % "!" est similaire à "#"
246 \printtoks[mode=2]{\def\foo#1!2#3{\hbox to 1cm{\hss$!1^#2_!3$\hss}}}|
247 produit les lignes suivantes dans le fichier log :
248
249 \columnseprule0.4pt
250 \begin{multicols}2
251 \specialcode\tktlcode|------ Begin token list ------
252 \def catcode 16 (primitive)
253 \foo catcode 16 (macro:#1->$#1$)
254 # catcode 6 (macro parameter charcater)
255 1 catcode 12 (character)
256 ! catcode 6 (macro parameter charcater)
257 2 catcode 12 (character)
258 # catcode 6 (macro parameter charcater)
259 3 catcode 12 (character)
260 { catcode 1 (begin-group character)
261 \hbox catcode 16 (primitive)
262 t catcode 11 (letter)
263 o catcode 11 (letter)
264 catcode 10 (blank space)
265 1 catcode 12 (character)
266 c catcode 11 (letter)
267 m catcode 11 (letter)
268 { catcode 1 (begin-group character)
269 \hss catcode 16 (primitive)
270 $ catcode 3 (math shift character)
271 ! catcode 6 (macro parameter charcater)
272 1 catcode 12 (character)
273 ^ catcode 7 (superscript character)
274 # catcode 6 (macro parameter charcater)
275 2 catcode 12 (character)
276 _ catcode 8 (subscript character)
277 ! catcode 6 (macro parameter charcater)
278 3 catcode 12 (character)
279 $ catcode 3 (math shift character)
280 \hss catcode 16 (primitive)
281 } catcode 2 (end-group character)
282 } catcode 2 (end-group character)
283 ------- End token list -------|
284 \end{multicols}
285
286 \section{Agir sur chaque token avec \texttt{\textbackslash toksdo}}
287 Cette macro parcourt tous les tokens un par un et indépendamment les uns des autres. L'utilisateur peut spécifier des critères à l'aide de \<motifs> et pour chacun, via un \<code> une action à effectuer sur le token ayant matché avec \<motifs>.
288
289 \subsection{Motifs élémentaires}
290 3 motifs élémentaires susceptibles de matcher avec un token sont disponibles, chacun étant accessible par le marqueur \verb|\r|, \verb|\R| et \verb|\S|.
291
292 \subsubsection{Le motif \texttt{\textbackslash r}}\label{motif:r}
293 La syntaxe de ce \<1-motif> est
294 \tktlcode/\r{<csv d'intervalles de tokens>:<csv d'intervalles de catcodes>}/
295 où un intervalle est de la forme «plage s'étendant entre deux tokens» de type \verb|<token1>-<token2>|, mais peut être réduit à un unique token \verb|<token>|.
296
297 La liste \<csv d'intervalles de catcodes> peut être remplacée par le caractère «\verb|*|» qui tient lieu de joker et remplace tout intervalle. Si la \<csv d'intervalles de catcode> est absente, elle est comprise comme «\verb|*|».
298
299 La virgule, le tiret et «\verb|:|» ne peuvent pas être spécifiés comme token puisqu'ils font partie de la syntaxe (voir le marqueur \verb|\R| pour contourner cette limitation).
300
301 À titre d'exemple :\par
302 \begin{tabular}{>\raggedleft p{6cm}p{9cm}}
303 \verb|\r{a-z:11}| & correspond avec tout token de \verb|a| à \verb|z| ayant un catcode de 11.\\
304 \verb|\r{a-z}| ou \verb|\r{a-z:*}| & correspond avec tout token de \verb|a| à \verb|z| quel que soit son catcode.\\
305 \verb|\r{a,e,i,o,u,y}| & correspond avec toute voyelle, quel que soit son catcode.\\
306 \verb|\r{a-z,A-Z,0-9:11,12}| & correspond avec tout caractère alphanumérique (minuscule, majuscule ou chiffre), ayant indifféremment un catcode de 11 ou 12.
307 \end{tabular}
308
309 Il est important de noter qu'\emph{aucun espace superflu} n'est toléré dans les syntaxes des \<csv> :
310 \begin{itemize}
311 \item \Verb*|\r{ a-z }| provoque une erreur de compilation «\texttt{! Improper alphabetic constant}», il faut écrire \verb|\r{a-z}|;
312 \item \Verb*|\r{1, ,2 }| est également fautif, il faut écrire \Verb*|\r{1, ,2}|.
313 \end{itemize}
314
315 \subsubsection{Le motif \texttt{\textbackslash R}}\label{motif:R}
316 La syntaxe de ce \<1-motif> est
317 \tktlcode/\R{<csv d'intervalles de charcodes>:<csv d'intervalles de catcodes>}/
318
319 Dans les deux listes csv, le caractère «\verb|*|» tient lieu de joker et remplace tout intervalle. Les charcodes sont des nombres écrits en chiffres (base 10) ou à la façon de \TeX : \verb|`\<char>|. Ainsi, «\verb|`\:|», «\verb|`\,|» et «\verb|`\-|» sont les entiers correspondant respectivement aux charcodes des tokens «\verb|:|», «\verb|,|» et «\verb|-|».
320
321 On a donc par exemple :\par
322 \begin{tabular}{>\raggedleft p{6cm}p{9cm}}
323 \verb|\R{*:10}| & correspond avec tout token de catcode 10 (qui est un espace pour \TeX)\\
324 \verb|\R{*:16}| & correspond avec tout token de catcode 16 (qui est un caractère ou une séquence de contrôle pour \TeX)\\
325 \verb|\R{106-115:11}| & correspond avec tout token de «\verb|j|» à «\verb|s|» ayant un catcode de 11\\
326 \verb|\R{`\a-`\z}| & est identique à \verb|\R{97-122}| qui est équivalent à \verb|\r{a-z}|\\
327 \verb|\R{`\,,`\;,`\::12}| & est identique à \verb|\R{44,59,58:12}| et correspond avec \verb|,| ou \verb|;| ou \verb|:| de catcode 12\\
328 \verb|\R{*:*}| & correspond avec n'importe quel token
329 \end{tabular}
330
331 \subsubsection{Le motif \texttt{\textbackslash S}}\label{motif:S}
332 La syntaxe de ce \<1-motif> est
333 \tktlcode/\S{<tokens>}/
334
335 Un token correspond s'il figure dans \<tokens> passés comme argument à \verb|\S|.
336
337 Dans les tokens «\verb|ab \foo{0 123}c d|», ceux qui matchent avec le motif «\verb|\S{1{a }\foo}|» sont encadrés en rouge\label{encadrerouge} :
338 \begin{center}
339 \fboxsep=1.5pt
340 \toksdo{ \S{1{a }\foo} -> \ifnum\selfcatcode=10 % si espace
341 \addtok{{\color{red}\fbox{\strut\textvisiblespace}}}%
342 \else
343 \setcatcode{12}%
344 \addtok{{\ttfamily\color{red}\fbox{\strut\self}}}%
345 \fi,
346 \R{*:*} -> \addtok{\,{\ttfamily\self}\,}
347 }{ab \foo{0 123}c d}
348 \end{center}
349
350 Les \<tokens> peuvent contenir un ou plusieurs occurrences \emph{non imbriquées} du marqueur \verb|\c|\label{marqueur:c:catcode}. La syntaxe de ce marqueur est
351 \tktlcode/\c{<catcode>}{<tokens>}/
352
353 Dans l'argument de \verb|\S|, l'action de \verb|\c| est de donner aux \<tokens> le \<catcode> passé dansle permier argument. Si le \<catcode> est réduit à 1 chiffre, les accolades sont facultatives. Il en est de même pour le 2\ieme{} argument s'il contient un seul token.
354
355 Si un token est une \<macro>, le seul catcode qu'elle peut recevoir est 12 auquel cas, les tokens de catcode 12 provenant de \verb|\string<macro>| seront créés.
356
357 Les catcodes acceptés dans le 1\ier{} argument de\verb|\c| sont : 1, 2, 3, 4, 6, 7, 8, 10, 11, 12 et 13. L'utilisateur devra être \emph{extrêmement attentif} aux conséquences d'un changement de catcode vers les catégories sensibles portant les numéros 1, 2 et 6.
358
359 Si l'on écrit
360 \tktlcode/\S{12\c{12}\bar3abc\c{11}{4 5.6}7\c78 9}/
361 alors les \<tokens> contenus dans l'argument de \verb|\S| sont :
362 \begin{center}
363 \catcode`\_11
364 \tktl_catcode_string{12\c{12}\bar3abc\c{11}{4 5.6}7\c78 9}
365 \expandafter\tktl_decode_enctoks\expandafter{\the\tktl_string_toks}{\printtoks[intertoks=0.75em]}
366 \end{center}
367
368 \subsection{Motifs}
369 Ce que l'on note \<motifs> pour \verb|\toksdo| est constitué d'un \<1-motif> élémentaire ou de plusieurs séparés par «\verb-|-» qui signifie «ou» :\par
370 \begin{tabular}{>\raggedleft p{7cm}p{9cm}}
371 \verb/\r{a-z:11} | \R{*:12}/ & correspond avec tout token étant une lettre de \verb|a| à \verb|z| de catcode 11 ou tout token de catcode 12 \\
372 \verb/\R{*:16} | S{01223456789.}/ & correspond avec tout token étant une macro, un chiffre ou un point\\
373 \verb/\r{0-9:12} | \r{a-z,A-Z:11} | \R{*:10}/ & correspond avec tout token ayant le catcode par défaut étant un chiffre, une lettre, ou un espace
374 \end{tabular}
375
376 \subsection{Utiliser \texttt{\textbackslash toksdo}}\label{toksdo}
377 Cette macro s'utilise de la façon suivante :
378 \tktlcode/\toksdo[<clés>=<valeurs>]
379 {
380 <motifs_1> -&> <code_1>,
381 <motifs_2> -&> <code_2>,
382 etc.
383 <motifs_n> -&> <code_n>
384 }{<tokens>}/
385 On peut spécifier autant de \<motifs> et de \<codes> associés que l'on souhaite.
386
387 Chaque \<code> est un code arbitraire\footnote{Si ce \<code> contient une virgule qui n'est pas entre accolades, il faut utiliser la syntaxe \<motifs>\texttt{->\char`\{ }\<code>\texttt{\char`\}}.} susceptible de modifier le token qui a matché avec \<motifs>. Dans ce \<code>, on peut utiliser les macros suivantes :
388 \begin{itemize}
389 \item \verb|\tokslen| qui est le nombre total de tokens;
390 \item \verb|\selfindex|, \verb|\selfcharcode| et \verb|\selfcatcode| qui, pour le token ayant matché, représentent son index (qui commence à 1 et finit à \verb|\tokslen|), son charcode et son catcode. Si le token est une macro, \verb|\selfcharcode| n'est \emph{pas} un nombre et vaut la macro elle-même ;
391 \item \verb|\addtok{<code>}| qui indique de quelle façon ajouter le token ayant matché au collecteur interne qui le recueille tous en vue des les afficher ou de les assigner en fin de processus;
392 \item \verb|\deltok| supprime le token ayant matché;
393 \item \verb|\setcharcode{<expression arithmétique>}| et \verb|\setcatcode{<expression arithmétique>}| changent le charcode et le catcode du token ayant matché. Une \<macro> ne peut recevoir que le catcode 12 et dans ce cas, les tokens provenant de \verb|\string<macro>| sont créés. Pour tout autre token, les catcodes acceptés par \verb|\setcatcode| sont 1, 2, 3, 4, 6, 7, 8, 10, 11, 12 et 13. Une attention particulière doit être portée à ce que l'on fait si on change un catcode pour 1, 2 ou 6.
394 \end{itemize}
395
396 Les \<clés> acceptées par la macro \verb|\toksdo| sont :
397 \begin{center}
398 \renewcommand\arraystretch{1.25}
399 \begin{tabular}{>\ttfamily p{3.5cm}>\ttfamily p{2.5cm}p{8cm}}\hline
400 \rmfamily Clé & \rmfamily Valeur par défaut & Description\\\hline
401 expand arg & 0 & nombre de développements que doit subir l'argument contenant les \<tokens> avant d'être pris en compte\\
402 collect & true & collecte tous les tokens retenus dans le but de les afficher ou les stocker.
403 Aucune collecte n'est faite si ce booléen est \verb|false|\\
404 assign & \<vide> & consigne d'assignation : une consigne d'assignation est tout code susceptible de se trouver devant le résultat mis entre accolades et le code qui est exécuté est donc \verb|<consigne>{<résultat>}|.
405 Si \<vide>, affiche le résultat. Si la valeur est une \<macro>, cette \<macro> doit être un registre de tokens qui recevra le résultat.
406 La valeur peut également être de la forme \verb|\def<macro>| où la \verb|<macro>| recevra le résultat\\\hline
407 \end{tabular}
408 \end{center}
409
410 Voici comment programmer le ROT13 :
411 \begin{doclatex}
412 \toksdo{
413 \r{a-m,A-M} -> \setcharcode{\selfcharcode + 13},
414 \r{n-z,N-Z} -> \setcharcode{\selfcharcode - 13}
415 }{Deux plus deux font quatre}
416 \end{doclatex}
417
418 Dans cet exemple, on remplace tout chiffre ou tiret par «\verb|x|» et tout espace par «\verb|_|» de catcode 12 :
419 \begin{doclatex}
420 \toksdo{
421 \r{0-9} | \S{-} -> \setcharcode{`x},
422 \R{*:10} -> \setcharcode{`\_}\setcatcode{12}
423 }{Votre mot de passe est : \textbf{758-457-384}, ne n'oubliez pas !}
424 \end{doclatex}
425
426 Ne garde que la première moitié des tokens :
427 \begin{doclatex}
428 \toksdo{\R{*:*} -> \ifnum\selfindex>\numexpr\tokslen/2\relax \deltok \fi}{123abcd689}
429 \end{doclatex}
430
431 Il est parfois nécessaire d'assigner le résultat à un registre de token au cas où les tokens obtenus contiennent le token de catcode 6 (\verb|#| par défaut) :
432 \begin{doclatex}
433 \newtoks\myresult
434 \toksdo[assign=\myresult]
435 {\S{2} -> \deltok }% supprime les "2"
436 {\def\foo#1{02#120}}
437 \the\myresult% exécute : \def\foo#1{0#10}
438 \foo{A}, \foo{xYz}
439 \end{doclatex}
440 Si l'on avant écrit «\verb|assign = \def\mymacro|», le code qui aurait été exécuté en coulisses est
441 \tktlcode/\def\mymacro{\def\foo#1{0#10}}/
442 Ce code est illégal en \TeX{} (erreur du type «\verb|Illegal parameter number in definition of \mymacro|»).
443
444 La clé \verb|collect|, lorsque \verb|false| indique de ne pas collecter les tokens. Cela peut faire sens si le code sur les tokens ayant matché ne les modifie pas. Voici comment compter les voyelles à l'aide d'un compteur :
445 \begin{doclatex}
446 \newcount\voyel \voyel=0
447 \toksdo[collect=false]{ \S{aeiouy} -> \advance\voyel 1 }{happy texing}<\the\voyel>
448 \end{doclatex}
449
450 L'argument de \verb|\setcharcode| et de \verb|\setcatcode| est évalué avec la primitive \verb|\numexpr| et donc, toute expression arithmétique acceptée par cette primitive est correcte. Ici, toutes les voyelles sont mises en majuscule :
451 \begin{doclatex}
452 \toksdo{ \S{aeiouy} -> \setcharcode{\selfcharcode + `A - `a} }{Deux plus deux font quatre}
453 \end{doclatex}
454
455 Voici comment, en 2 passes, extraire les tokens se trouvant dans le plus haut niveau d'imbrication d'accolades :
456 \begin{doclatex}
457 \newcount\nestcnt \nestcnt=0 % compte le niveau d'imbrication
458 \newcount\maxnestcnt \maxnestcnt=0 % est le plus haut niveau d'imbrication
459 \def\mycode{12{34{5{67}8}}9{{ab}c}{{d{e}f}}g}
460 \toksdo[expand arg=1,collect=false]{
461 \R{*:1} -> \advance\nestcnt1 \ifnum\nestcnt>\maxnestcnt \maxnestcnt=\nestcnt \fi,
462 \R{*:2} -> \advance\nestcnt-1
463 }{\mycode}Imbrication max = \the\maxnestcnt\par
464 Tokens les plus imbriqués :
465 \toksdo[expand arg=1]{
466 \R{*:1} -> \advance\nestcnt1 \deltok,% supprimer accolades ouvrantes
467 \R{*:2} -> \advance\nestcnt-1 \deltok,% supprimer accolades fermantes
468 \R{*:*} -> \ifnum\nestcnt<\maxnestcnt \deltok \fi% supprimer tout sauf au plus haut niveau d'imbrication
469 }{\mycode}
470 \end{doclatex}
471
472 \subsection{Utiliser \texttt{\textbackslash toksdo} et \texttt{\textbackslash addtok}}\label{addtok}
473 Lorsque la clé \verb|collect| est \verb|true|, les tokens sont collectés. Une fois qu'ils ont été traités et éventuellement modifié par \verb|\setcharcode| ou \verb|\setcatcode|, chacun est ajouté tel quel au collecteur interne qui est sollicité en fin de processus pour afficher les tokens ou les assigner si la clé \verb|assign| le spécifie.
474
475 Il est possible de modifier la façon dont sont ajoutés les tokens au collecteur interne via la macro \verb|\addtok{<code>}|, où \<code> est un code arbitraire dans lequel \verb|\self|\label{marqueur:self} représente le token lui-même.
476
477 Par défaut et au début de chaque code qui suit «\hbox{\verb|<motifs>|\Verb| -> |}», la macro \verb|\addtok| est initialisée à sa valeur par défaut:
478 \tktlcode|\addtok{\self}|
479 ce qui signifie que chaque token doit être ajouté tel quel.
480
481 Si l'on écrit \verb|\addtok{\self\self}|, les tokens ayant matché sont doublés. Avec \verb|\addtok{\fbox{\self}}|, ils sont encadrés à l'aide de la macro \verb|\fbox| de \LaTeX.
482
483 La macro \verb|\deltok| est équivalente à \verb|\addtok{}|.
484
485 Dans la majorité des cas, \verb|\self| représente un seul token : celui qui est en cours de traitement. Ce n'est \emph{que} lorsqu'une macro est détokénisée via \verb|\setcatcode{12}| que \verb|\self| représente plusieurs tokens.
486
487 Dans cet exemple, chaque macro est détokénisée et encadrée, et tous les espaces sont remplacés par «\Verb*| _ |»:
488 \begin{doclatex}
489 \fboxsep=2pt
490 \toksdo{ \R{*:16} -> \setcatcode{12}\addtok{\fbox{\self}},% détokenize et encadre
491 \R{*:10} -> \addtok{ \string_ }
492 }{a b\foo12. 3\baz- 9}
493 \end{doclatex}
494
495 Chaque chiffre 1 est doublé et chaque 0 est remplacé par un espace :
496 \begin{doclatex}
497 \toksdo{ \S{1} -> \addtok{\self\self},
498 \S{0} -> \setcatcode{10}% autre possibilité : \addtok{ }
499 }{10110101}
500 \end{doclatex}
501
502 Les macros \verb|\selfindex|, \verb|\selfcharcode| et \verb|\selfcatcode| ne doivent \emph{pas} être utilisées dans l'argument de \verb|\addtok|, car elles seront ajoutées telles quelles dans le collecteur interne. Ce n'est qu'au moment de l'exécution et après avoir collecté le dernier token qu'elles seront développées, et contiendront à ce moment les données du dernier token. Si l'on souhaite effectuer des tests sur l'index, le charcode ou le catcode du token à ajouter, il faut le faire à l'extérieur de l'argument de \verb|\addtok|. Voici le code source dont le résultat est visible en page~\pageref{encadrerouge}:
503 \begin{doclatex}
504 Dans les tokens «\verb|ab \foo{0 123}c d|», ceux qui matchent avec
505 le motif «\verb|\S{1{a }\foo}|» sont encadrés en rouge :\par
506 \hfill
507 \fboxsep=1.5pt
508 \toksdo{ \S{1{a }\foo} -> \ifnum\selfcatcode=10 % si espace
509 \addtok{{\color{red}\fbox{\strut\textvisiblespace}}}%
510 \else% si pas espace
511 \setcatcode{12}% détokéniser
512 \addtok{{\ttfamily\color{red}\fbox{\strut\self}}}% encadrer en rouge
513 \fi,
514 \R{*:*} -> \addtok{\,{\ttfamily\self}\,}% pour tout autre token, espacer un petit peu
515 }{ab \foo{0 123}c d}%
516 \hfill\null
517 \end{doclatex}
518
519 \section{Compter les tokens avec {\ttfamily\textbackslash tokscount}}\label{tokscount}
520 La macro
521 \tktlcode/\tokscount[<clés>=<valeurs>]{<motifs>}{<tokens>}/
522 compte combien de tokens matchent avec \<motifs> dans les \<tokens>. Si aucun motif n'est spécifié (argument vide), la macro compte tous les tokens.
523
524 Les \<clés> disponibles sont les suivantes :
525 \begin{center}
526 \renewcommand\arraystretch{1.25}
527 \begin{tabular}{>\ttfamily p{3.5cm}>\ttfamily p{2.5cm}p{8cm}}\hline
528 \rmfamily Clé & \rmfamily Valeur par défaut & Description \\\hline
529 expand arg & 0 & nombre de développements que doit subir l'argument contenant les \<tokens> avant d'être pris en compte\\
530 assign & \<vide> & consigne d 'assignation. Si \<vide>, affiche le nombre de tokens ayant matché. Sinon, doit contenir une consigne d'assignation du type
531 \verb|\def<macro>| pour assigner à la \<macro> le résultat\\
532 assign match & \<vide> & consigne d'assignation. Si \<vide> les tokens ayant matché ne sont pas collectés. Sinon, doit contenir une consigne d'assignation
533 \verb|\def<macro>| pour les assigner à une macro ou \verb|<macro>| pour les assigner à un registre de tokens\\\hline
534 \end{tabular}
535 \end{center}
536
537 Les \<motifs> acceptés par \verb|\tokscount| sont les mêmes que pour \verb|\toksdo|.
538
539 \begin{doclatex}
540 1) \tokscount{ \r{a-z} | \S{10} }{ab1023truc098}\quad
541 2) \tokscount[assign=\def\cc]{ \R{*:16} }{ab\x123truc\zzz0\yy98}<\cc>\quad% compte les macros
542 3) \tokscount[assign=\def\cc,assign match=\def\xx]{ \S{01} }{1{a01}1{0{b100}}1}<\cc><\xx>\quad% compte les 0 et 1
543 4) \tokscount{ \R{*:12} | \S{\foo\bar\zid} }{ab\foo c12d*-ef}\quad% compte les tokens "lettre" ou macros \foo\bar\zid
544 5) \tokscount{}{12{34}5}% compte tous les tokens
545 \end{doclatex}
546
547 \section{Grammaires PEG}
548 Dans un ensemble de tokens, certains peuvent matcher avec des motifs que l'on peut organiser en grammaire de type PEG (Parsing Expresion Grammar). À chaque fois qu'une correspondance a lieu avec un motif, les tokens ayant matché sont consommés et ne sont plus disponibles pour les motifs suivants (sauf pour les prédicats, voir plus bas). S'il n'y a pas de correspondance, aucun token n'est consommé.
549
550 \subsection{Les 5 marqueurs de motifs}\label{motifs}
551 Le package \tktl met à disposition 5 motifs élémentaires définis par 5 marqueurs pour construire des motifs plus complexes :
552
553 \begin{itemize}
554 \item le motif \verb|\r{<csv intervalles de caracatères>:<csv intervalles de catcode>}| décrit à la page~\pageref{motif:r};
555 \item le motif \verb|\R{<csv intervalles de charcodes>:<csv intervalles de catcode>}| décrit à la page~\pageref{motif:R};
556 \item le motif \verb|\S{<tokens>}| décrit à la page~\pageref{motif:S};
557 \item le motif \verb|\s{<tokens>}|\label{motif:s} : tout ensemble de tokens exactement constitué des \<tokens> passé en argument de \verb|\s| matche avec ce motif : il s'agit donc d'une correspondance exacte entre chaines de tokens.\par Tout comme avec le marqueur \verb|\S|, il est possible de changer les catcodes de certains tokens à l'aide du marqueur \verb|\c| selon la syntaxe \verb|\c{<catcode>}{<tokens>}|;
558 \item le motif \verb|\.|\label{motif:dot} qui matche avec tout token et qui est équivalent à \verb|\R{*:*}|.
559 \end{itemize}
560
561 \subsection{Répétitions}
562 Chaque \<1-motif> peut être suivi d'un indicateur de répétition si l'on souhaite spécifier le nombre de fois que la correspondance se produit. Les marqueurs de répétition sont :
563 \begin{itemize}
564 \item \verb|^<chiffre>| ou \verb|^{<nombre>}| : demande à ce que la correspondance se répète exactement le nombre de fois passé en argument de \verb|^|;
565 \item \verb|^{<min>-<max>}| : demande à ce que la correspondance se répète entre \verb|<min>| et \verb|<max>|. Si \verb|<min>| est absent, il est compris comme 0. Si \verb|<max>| est absent, il n'y a aucune limite sur nombre de répétition maximal. Les deux nombres ne peuvent pas être absents en même temps.
566 \item «\verb|+|» : 1 ou plusieurs répétitions (est équivalent à \verb|^{1-}|);
567 \item «\verb|*|» : 0 ou plusieurs répétitions (est équivalent à \verb|^{0-}|);
568 \item «\verb|?|» : 0 ou 1 répétition (est équivalent à \verb|^{0-1}|);
569 \end{itemize}
570
571 Si aucun marqueur de répétition n'est présent après un \<1-motif>, la consigne \verb|^1| est implicitement passée.
572
573 Il est important de noter que \emph{dans tous les cas}, le plus grand nombre possible de répétitions est consommé ; c'est un comportement qui est toujours «gourmand».
574
575 \subsection{Prédicats}
576 Chaque \<1-motif> peut être précédé du caractère «\verb|!|» ou «\verb|&|» qui en fait un prédicat:
577 \begin{itemize}
578 \item le prédicat \verb|!<1-motif>| matche s'il n'y a pas correspondance avec le \<1-motif>
579 \item le prédicat \verb|&<1-motif>| matche s'il y a correspondance avec le \<1-motif>.
580 \end{itemize}
581
582 La règle dans les grammaires PEG est qu'\emph{un prédicat ne consomme jamais de tokens} : on peut donc comprendre un prédicat comme un test sur ce qui va suivre sans bouger de position.
583
584 \subsection{Concaténation de motifs}
585 Le caractère «\verb|:|» entre 2 \<1-motif> indique de matcher avec le premier \emph{et} le second. On n'est évidemment pas limité à 2 \<1-motif>, il peut y en avoir autant que l'on veut.
586
587 \begin{tabular}{>\raggedleft p{6cm}p{9cm}}
588 \verb|&\r{0-9}^{3-} : \r{0-9}^2| & s'il y a au moins 3 chiffres, matche avec les 2 premiers\\
589 \verb|\r{a-z}+ : \R{*:10}? : \S{01}^2| & matche avec une ou plusieurs lettres minuscules suivies d'un espace optionnel suivi de 2 chiffres binaires\\
590 \verb|\r{1-9}+ : \s{00} : !\.| & matche avec un nombre constitué d'au moins 1 chiffre non nul suivi de "\verb|00|" qui doivent être
591 les \emph{derniers tokens}, car le prédicat «\verb|!\.|» signifie «ne doit pas être suivi d'un token»
592 \end{tabular}
593
594 \subsection{Choix entre motifs}
595 Le caractère «\verb/|/» entre 2 \<1-motif> indique de matcher avec le premier \emph{ou} avec le second. On n'est évidemment pas limité à 2 motifs, il peut y en avoir autant que l'on veut. Si une correspondance a lieu pour un \<1-motif>, elle est retenue et aucun autre \<1-motif> qui suit ne sera testé : il s'agit donc d'un choix ordonné. Si l'on écrit
596 \tktlcode/\r{0-9}^5 | \S{01}^2/
597 le 2\ieme{} test ne sera jamais effectué puisqu'il est inclus dans le premier. Il est donc important de commencer par les tests les plus spécifiques et de terminer par les plus généraux si les portées des motifs se chevauchent ou pire sont imbriquées.
598
599 L'opérateur de concaténation «\verb|:|» est prioritaire sur celui du choix «\verb/|/» et donc
600 \tktlcode/<a> : <b> | <c> | <d> : <e>/
601 se comprend comme \verb|<a>:<b>| ou \verb|<c>| ou \verb|<d>:<e>|.
602
603 \subsection{Groupement de motifs}
604 Tout \<1-motif> ou combinaison de \<1-motif> notée \<motifs>, peut être mis entre accolades pour devenir un nouveau \<1-motif> qui peut, à son tour, être précédé d'un prédicat et suivi d'une spécification de répétitions selon la syntaxe déjà décrite:
605 \tktlcode/<prédicat>{<motifs>}<répétitions>/
606
607 \subsection{Espaces}
608 Dans la syntaxe des motifs, les espaces sont ignorés.
609
610 Ainsi
611 \tktlcode/\r{0-9} ^ 2 : & \r{a-z}^3 : \r{a-z}^ 2/
612 est équivalent à
613 \tktlcode/\r{0-9}^2:&\r{a-z}^3:\r{a-z}^2/
614
615 \subsection{Priorités}
616 Les priorités entre opérateurs sur les \<1-motif> sont les suivantes (plus le numéro est élevé, plus la priorité l'est) :
617 \begin{center}
618 \renewcommand\arraystretch{1.25}
619 \begin{tabular}{>\ttfamily p{3.5cm}>\ttfamily p{1.5cm}p{8.5cm}}\hline
620 Opérateur & \rmfamily Priorité & Description\\\hline
621 \verb|{<motifs>}| & 5 & groupement de motifs qui devient un \<1-motif>\\
622 \verb|<1-motif>?| & 4 & matche 0 ou 1 fois\\
623 \verb|<1-motif>*| & 4 & matche 0 fois ou plus\\
624 \verb|<1-motif>+| & 4 & matche 1 fois ou plus\\
625 \verb|<1-motif>^{n}| & 4 & matche \verb|n| fois\\
626 \verb|<1-motif>^{a-b}| & 4 & matche entre \verb|a| et \verb|b| fois\\
627 \verb/!<1-motif>/ & 3 & matche si \<1-motif> ne matche pas, sans consommer de token\\
628 \verb/&<1-motif>/ & 3 & matche si \<1-motif> matche, sans consommer de token\\
629 \<1-motif$_1$>\verb/:/\<1-motif$_2$> & 2 & matche avec \<1-motif$_1$> puis avec \<1-motif$_2$>\\
630 \<1-motif$_1$>\verb/|/\<1-motif$_2$> & 1 & matche avec \<1-motif$_1$> ou \<1-motif$_2$> (choix ordonné)\\\hline
631 \end{tabular}
632 \end{center}
633
634 \subsection{Nom des motifs}
635 Tout motif peut être défini et nommé pour réutiliser ce motif ultérieurement avec une syntaxe plus légère et facile à retenir\label{defpattern} :
636 \tktlcode|\defpattern<nom de motif>{<motifs>}|
637 Le \<nom de motif> \emph{doit} être une séquence de contrôle. Cette séquence de contrôle n'est pas définie ou redéfinie par \verb|\defpattern|, c'est également un marqueur dont la signification n'a pas d'importance.
638
639 \section{Tester une correspondance avec {\ttfamily\textbackslash ifpegmatch}}\label{ifpegmatch}
640 \subsection{Syntaxe}
641 La macro \verb|\ifpegmatch| a la syntaxe suivante
642 \tktlcode/\ifpegmatch[<clés>=<valeurs>]{<motifs>}{<tokens>}{<code si match>}{<code si non match>}/
643
644 Lorsque toutes les valeurs sont par défaut, cette macro teste si les \<motifs> font matcher des tokens se trouvant en début des \<tokens>.
645
646 Les \<clés> disponibles sont :
647 \begin{center}
648 \renewcommand\arraystretch{1.25}
649 \begin{tabular}{>\ttfamily p{3.5cm}>\ttfamily p{3cm}p{8cm}}\hline
650 \rmfamily Clé & \rmfamily Valeur par défaut & Description\\\hline
651 expand arg & 0 & nombre de développements que doit subir l'argument contenant les \<tokens> avant d'être pris en compte \\
652 mode & 1 & mode de recherche de correspondances \\
653 capture name & \<vide> & nom des captures \\
654 assign prematch & \verb|\def\prematchtoks| & consigne d'assignation pour les tokens précédant ceux qui ont matché \\
655 assign match & \verb|\def\matchtoks| & consigne d'assignation pour les tokens ayant matché \\
656 assign postmatch & \verb|\def\remaintoks| & consigne d'assignation pour les tokens précédant ceux qui ont matché \\\hline
657 \end{tabular}
658 \end{center}
659
660 Ici, on teste si les \<tokens> commencent par 2 chiffres, 1 espace optionnel et au moins 1 lettre minuscule
661 \begin{doclatex}
662 \defpattern\okmatch{ \r{0-9:12}^2 : \R{*:10}? : \r{a-z:11}+ }
663 1) \ifpegmatch{\okmatch}{73 ab:*ij}{V}{F}\quad
664 2) \ifpegmatch{\okmatch}{45foobar2000}{V}{F}\quad
665 3) \ifpegmatch{\okmatch}{854tex 8}{V}{F}\quad
666 4) \ifpegmatch{\okmatch}{1 2 b3c}{V}{F}\quad
667 \end{doclatex}
668
669 Construisons une grammaire simple pour tester si un argument commence une opération arithmétique du type \tktlcode/<entier relatif><opération><entier positif>/
670 \begin{doclatex}
671 \defpattern\sp{ \R{*:10} } % espace
672 \defpattern\digit{ \r{0-9} }% chiffre
673 \defpattern\posint{ \digit+ }% entier positif
674 \defpattern\int{ \S{+-}? : \posint }% entier relatif
675 \defpattern\op{ \S{+-*/} }% opération math
676 \defpattern\okmatch{ \sp* : \int : \sp* : \op : \sp* : \posint : \sp* }
677 1) \ifpegmatch\okmatch{2*3}{V}{F}\quad
678 2) \ifpegmatch\okmatch{-7 + 1 }{V}{F}\quad
679 3) \ifpegmatch\okmatch{ a + 9 }{V}{F}\quad
680 4) \ifpegmatch\okmatch{ -2 / 6 + 3 }{V}{F}\quad
681 5) \ifpegmatch\okmatch{ +2026- 4068}{V}{F}\quad
682 6) \ifpegmatch\okmatch{ -3 }{V}{F}\quad
683 7) \ifpegmatch\okmatch{2a-3b}{V}{F}\par
684 La primitive \verb|\int| n'est pas redéfinie : $\int x^2dx$
685 \end{doclatex}
686
687 Avec le prédicat «\verb|: !\.|» rajouté à la fin de \verb|\okmatch|, la ligne 4 aurait affiché «F» car il reste «\Verb*|+ 3 |» après les tokens ayant matché.
688
689 \subsection{Mode}
690 La macro \verb|\ifpegmatch| peut chercher des correspondances selon plusieurs modes, spécifiés via la clé «\verb|mode|» :
691 \begin{itemize}
692 \item par défaut, \verb|mode=1| indique que le match doit se produire au début des \<tokens> ;
693 \item \verb|mode=0| indique que tous les \<tokens> doivent matcher ; c'est le mode le plus strict ;
694 \item \verb|mode=2| indique que le match peut se produire n'importe où dans les \<tokens> ; c'est le mode le moins contraignant.
695 \end{itemize}
696
697 \subsection{Délivrance de tokens}
698 La macro \verb|\ifpegmatch| renvoie également quelques informations :
699 \begin{itemize}
700 \item par défaut, la macro \verb|\matchtoks| contient les tokens qui ont matché et elle est vide si aucune correspondance n'a été trouvée ;
701 \item par défaut, la macro \verb|\remaintoks| contient les tokens qui restent après ceux qui ont matché;
702 \item par défaut, la macro \verb|\prematchtoks| contient les tokens qui précèdent ceux qui ont matché (ne peut contenir des tokens uniquement lorsque \verb|mode=2|);
703 \item la macro \verb|\matchposition| contient la position du premier token ayant matché et 0 si aucun match ne s'est produit.
704 \end{itemize}
705
706 \begin{doclatex}
707 1) \ifpegmatch[mode=0]{ \r{A-Z}^3 }{1ABC6}{V}{F}, match=<\matchtoks>, reste=<\remaintoks>, pos=\matchposition\par
708 2) \ifpegmatch[mode=1]{ \r{A-Z}^3 }{1ABC6}{V}{F}, match=<\matchtoks>, reste=<\remaintoks>, pos=\matchposition\par
709 3) \ifpegmatch[mode=2]{ \r{A-Z}^3 }{1ABC6}{V}{F}, match=<\matchtoks>, reste=<\remaintoks>, pos=\matchposition\par
710 4) \ifpegmatch[mode=0]{ \r{A-Z}^3 }{ZZZ12}{V}{F}, match=<\matchtoks>, reste=<\remaintoks>, pos=\matchposition\par
711 5) \ifpegmatch[mode=1]{ \r{A-Z}^3 }{ZZZ12}{V}{F}, match=<\matchtoks>, reste=<\remaintoks>, pos=\matchposition\par
712 6) \ifpegmatch[mode=2]{ \r{A-Z}^3 }{ZZZ12}{V}{F}, match=<\matchtoks>, reste=<\remaintoks>, pos=\matchposition
713 \end{doclatex}
714
715 \subsection{Captures}\label{marqueur:c:capture}
716 Le marqueur \verb|\c|, lorsqu'il est placé devant un \<1-motif>, indique que les tokens qui matchent avec ce \<1-motif> doivent être capturés ainsi que leur position. Si un \<1-motif> est un prédicat, aucune capture n'est faite. Les captures sont rangée dans l'ordre chronologique dans lequel elles ont été faites et sont délivrées, en 2 développements, par \verb|\tokscapture{<index>}| ou par \verb|\tokscapture{<nom>:<index>}| . Le \verb|<nom>| est optionnel se règle avec la clé \verb|name| et l'\verb|<index>| est le numéro d'ordre de la capture.
717
718 Si l'\verb|<index>| vaut 0, toutes les captures sont mises entre accolades et listées dans une csv de la forme :
719 \tktlcode/{<capture_1>},{<capture_2>},...,{<capture_n>}/
720
721 De la même façon, la macro \verb|\poscapture{<index>}| ou \verb|\poscapture{<nom>:<index>}| rend les positions de captures à la différence que si \<index> vaut 0, les positions sont mises dans une csv \emph{sans être mises entre accolades} :
722 \tktlcode/<position_1>,<position_2>,...,<position_n>/
723
724 Si un \<index> dépasse l'index maximal, un message d'erreur est émis.
725
726 Si \verb|\c| se trouve après un \<1-motif>, seule la position est capturée.
727
728 Dans cet exemple, 2 captures complètes (tokens+position) et une capture de position sont faites :
729 \begin{doclatex}
730 \ifpegmatch[mode=2]{ \c\r{a-z}+ : \c\r{0-9}^2\c }{12abc666def}{V}{F}\par
731 toks : <\detokenize\expandafter\expandafter\expandafter{\tokscapture{0}}>\qquad
732 1=<\tokscapture{1}>, 2=<\tokscapture{2}>\par
733
734 pos : <\poscapture{0}>\qquad
735 1=<\poscapture{1}>, 2=<\poscapture{2}>, 3=<\poscapture{3}>
736 \end{doclatex}
737
738 Dans cet exemple, on définit une grammaire qui fait matcher une écriture scientifique de la forme $a\times10^{b}$ et qui capture les deux nombres $a$ et $b$ :
739 \begin{doclatex}
740 \defpattern\sp{ \R{*:10} }
741 \defpattern\sign{ \S{+-} }
742 \defpattern\digit{ \r{0-9} }
743 \defpattern\integer{ \digit+ }
744 \defpattern\decsep{ \S{.,} }
745 \defpattern\scidec{ \sign? : \r{1-9} : {\decsep : \digit+}? }
746 \defpattern\opbr{ \R{*:1} }
747 \defpattern\clbr{ \R{*:2} }
748 \defpattern\^{ \R{*:7} }
749 \defpattern\exponent{ \opbr : \sp? : \c{\sign? : \sp? : \integer} : \sp? : \clbr | \c\digit }
750 \defpattern\sci{\c\scidec : \sp? : \s{\times10} : \sp? : \^ : \sp? :\exponent}
751 1) \ifpegmatch\sci{3\times10^5} {<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
752 2) \ifpegmatch\sci{-2.25\times10^{-3}} {<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
753 3) \ifpegmatch\sci{-0.75\times10^7 } {<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
754 4) \ifpegmatch\sci{15\times10^0} {<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
755 5) \ifpegmatch\sci{1.5\times10^ 1 } {<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
756 6) \ifpegmatch\sci{-2.75 \times 10 ^ { 11 }}{<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
757 7) \ifpegmatch\sci{-9.96\times10^{ -2 }} {<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
758 8) \ifpegmatch\sci{-0\times10 ^0} {<\tokscapture{1}> <\tokscapture{2}>}{Faux}\par
759 9) \ifpegmatch\sci{-1\times10^ {- 7 }} {<\tokscapture{1}> <\tokscapture{2}>}{Faux}
760 \end{doclatex}
761
762 \subsection{Grammaires récursives}
763 Le package \tktl admet des grammaires récursives, mais aucune optimisation n'est faite et la façon de les traiter reste naïve. Par conséquent, certaines grammaires récursives, en particulier celles conduisant à des «récursivités à gauche» vont mener à des boucles infinies.
764
765 Cela étant, il est possible d'utiliser des grammaires récursives, mais y mettre des captures tend à être un peu aléatoire car l'ordre de ces captures n'est pas évident et dépend de la définition même de cette grammaire et donc du parcours de l'arbre qui en découle.
766
767 Voici une grammaire récursive capturant une expression arithmétique comportant les 4 opérations avec parenthèses :
768 \begin{doclatex}
769 \defpattern\num{ \r{0-9}+ }
770 \defpattern\term{ \num | \s{(} : \expr : \s{)} }
771 \defpattern\factor{ \term : {\S{*/} : \term }* }
772 \defpattern\expr{ \factor : {\S{+-} : \factor }* }
773 1) \ifpegmatch[mode=0]\expr{1+3}{V}{F}\quad
774 2) \ifpegmatch[mode=0]\expr{1-2*3}{V}{F}\quad
775 3) \ifpegmatch[mode=0]\expr{3*4+6}{V}{F}\quad
776 4) \ifpegmatch[mode=0]\expr{3-(1-2*3)}{V}{F}\quad
777 5) \ifpegmatch[mode=0]\expr{3*4*(1-3*2-(1-3/7)*3)/(1/7+2*3)*3-5}{V}{F}\quad
778 6) \ifpegmatch[mode=0]\expr{6-9*(2-3)+4/5}{V}{F}
779 \end{doclatex}
780
781 Cette grammaire s'assure que l'expression est commence par une parenthèse, contient une expression équilibrée en parenthèses :
782 \begin{doclatex}
783 \defpattern\nobrtext{ { !\S{()} : \. }+ }
784 \defpattern\inparen{ \nobrtext : \inparen* | \s{(} : \inparen* : \s{)} }
785 \defpattern\expr{ &\s{(} : \inparen : !\. }% prédicats -> doit commencer par '(' et finir par ')'
786 1) \ifpegmatch\expr{a(b)c}{V}{F}\quad
787 2) \ifpegmatch\expr{(a(abc)()d)}{V}{F}\quad
788 3) \ifpegmatch\expr{(a(bc))df)}{V}{F}\quad
789 4) \ifpegmatch\expr{((abc)d((e)f)g)}{V}{F}\quad
790 5) \ifpegmatch\expr{((foo)b(((b)a)r)}{V}{F}
791 \end{doclatex}
792
793 \section{Compter les correspondances avec {\ttfamily\textbackslash pegcount}}\label{pegcount}
794 La macro
795 \tktlcode/\pegcount[<clés>=<valeurs>]{<motifs>}{<tokens>}/
796 compte combien de fois les \<motifs> matchent dans les \<tokens>. Chaque position est sauvegardée et chaque correspondance est capturée pour être facilement restituée.
797
798 Aucune capture explicitement demandée par \verb|\c| n'est permise et est ignorée.
799
800 Les \<clés> disponibles sont :
801 \begin{center}
802 \renewcommand\arraystretch{1.25}
803 \begin{tabular}{>\ttfamily p{3.5cm}>\ttfamily p{2.5cm}p{8cm}}\hline
804 \rmfamily Clé & \rmfamily Valeur par défaut & Description\\\hline
805 expand arg & 0 & nombre de développements que doit subir l'argument contenant les \<tokens> avant d'être pris en compte.\\
806 assign & \<vide> & si vide, affiche le nombre de correspondances. Sinon, doit contenir une consigne d'assignation du type
807 \verb|\def<macro>| pour assigne à la \<macro> le résultat.\\
808 assign positions & \verb|\def\matchposlist| & consigne d'assignation de la liste des positions. Si \<vide> aucune capture n'est effectuée. Sinon, doit
809 contenir une consigne d'assignation \verb|\def<macro>| pour assigner la liste des positions à une \<macro>\\
810 name & \<vide> & est le nom des captures qui sont restituées par \verb|\tokscapture|\\\hline
811 \end{tabular}
812 \end{center}
813
814 Les captures sont délivrées, en 2 développements, par \verb|\tokscapture{[<nom>:]<index>}|. Le \verb|<nom>| est optionnel se règle avec la clé \verb|name| et l'\verb|<index>| est le numéro d'ordre de la capture. Si l'\verb|<index>| vaut 0, toutes les captures sont mises entre accolades et listées dans une csv de la forme :
815 \tktlcode/{<capture_1>},{<capture_2>},...,{<capture_n>}/
816
817 \begin{doclatex}
818 1) \pegcount{ \r{0-9}+ : \r{a-z}+ }{foo25bar}, <\matchposlist>\par% chiffres suivis de lettres
819 2) \pegcount{ \r{0-9}+ : \r{a-z}+ }{a12bcd,4b,z875bar}, <\matchposlist>,
820 "\tokscapture{0}", 1="\tokscapture{1}", 2="\tokscapture{2}", 3="\tokscapture{3}"\par% chiffres suivis de lettres
821 3) \pegcount{ \s{+} : {\r{a-c}^2 : \r{0-9}}+ : \s{+} }{+ab3+..+bb6ab8ca7+..+aa1bb2+..},
822 <\matchposlist>,
823 1="\tokscapture{1}", 2="\tokscapture{2}", 3="\tokscapture{3}"
824 \end{doclatex}
825
826 \section{Remplacements avec {\ttfamily\textbackslash pegreplace}}\label{pegreplace}
827 La macro
828 \tktlcode/\pegreplace[<clés>=<valeurs>]
829 {
830 <motifs_1> -&> <remplacement_1>,
831 <motifs_2> -&> <remplacement_2>,
832 etc.
833 <motifs_n> -&> <remplacement_n>
834 }{<tokens>}/
835 cherche tous les \<motifs> dans les \<tokens> et pour chaque correspondance, remplace les tokens ayant matché par le code défini dans \<remplacement>.
836
837 Les \<clés> disponibles sont :
838 \begin{center}
839 \renewcommand\arraystretch{1.25}
840 \begin{tabular}{>\ttfamily p{3.5cm}>\ttfamily p{2.5cm}p{8cm}}\hline
841 \rmfamily Clé & \rmfamily Valeur par défaut & Description\\\hline
842 expand arg & 0 & nombre de développements que doit subir l'argument contenant les \<tokens> avant d'être pris en compte.\\
843 mode & 2 & définit selon quel mode \verb|\pegreplace| doit chercher les correspondances\\
844 assign & \<vide> & si vide, affiche le \<tokens> obtenus après les avoir fait les remplacements. Sinon, doit contenir une
845 consigne d'assignation pour assigner le résultat à une macro avec \verb|\def<macro>| ou à un registre de tokens.\\\hline
846 \end{tabular}
847 \end{center}
848
849 Il faut comprendre toutes les positions dans \<tokens> sont envisagées, de la position $1$ à la position $L$, si $L$ est le nombre de tokens. Pour chaque position, tous les \<motifs> sont successivement testés pour savoir si une correspondance se produit à cette position. Si un \<motif$_i$> matche à la position $k$, \<remplacement$_i$> correspondant est effectué et \verb|\pegreplace| est prêt à passer à la position $k+1$. La clé \verb|mode| doit être un entier compris entre 0 et 2 qui spécifie comment doit se comporter la macro \verb|\pegreplace| après que la première correspondance ait été rencontrée et le premier remplacement fait:
850 \begin{itemize}
851 \item \verb|mode=0| indique qu'après la première correspondance à la position $k$, aucune autre position ne sera examinée, plus aucune action n'est effectuée et la macro \verb|\pegreplace| a terminé son travail;
852 \item \verb|mode=1| indique que toutes les positions suivantes seront examinées, mais si un \<motifs$_k$> matche, il est ensuite neutralisé et ne pourra plus matcher par la suite, autrement dit, chaque \<motifs> ne peut matcher qu'une fois au maximum;
853 \item \verb|mode=2|, qui est la valeur par défaut, indique que toutes les positions suivantes seront examinées et que chaque \<motifs> peut matcher autant de fois que nécessaire.
854 \end{itemize}
855
856 Le \<remplacement> est un code arbitraire ne contenant pas de virgule où peut figurer «\verb|\0|»\label{marqueur:0} qui signifie «tokens qui ont matché», «\verb|\1|» est la première capture faite par \verb|\c|, «\verb|\2|» est la deuxième et ainsi de suite jusqu'à «\verb|\9|». Il faut noter que les espaces avant et après \<remplacement> sont supprimés. Si un \<remplacement> est susceptible de contenir une virgule ou si l'on souhaite préserver les espaces avant ou après lui, il faut mettre le tout entre accolades.
857
858 Par exemple, pour transformer chaque mot en list csv et augmenter les espaces, il faudrait écrire
859 \begin{doclatex}
860 \pegreplace{
861 \r{a-z,A-Z} : &\. : !\R{*:10} -> {\0, } ,% accolades nécessaires ici
862 \R{*:10} -> \quad
863 }{Happy TeXing}
864 \end{doclatex}
865
866 Pour illustrer le comportement de \verb|\pegreplace| selon la valeur de la clé \verb|mode|, dans cet exemple, on encadre toute suite de 2 lettres minuscules et on met entre chevrons tout chiffre de 1 à 5 :
867 \begin{doclatex}
868 \fboxsep=1pt
869 \pegreplace[mode=0]{
870 \r{a-z}^2 -> \fbox{\strut\0},
871 \S{12345} -> $\langle\0\rangle$
872 }{6foob1baz327z}
873
874 \pegreplace[mode=1]{
875 \r{a-z}^2 -> \fbox{\strut\0},
876 \S{12345} -> $\langle\0\rangle$
877 }{6foob1baz327z}
878
879 \pegreplace[mode=2]{
880 \r{a-z}^2 -> \fbox{\strut\0},
881 \S{12345} -> $\langle\0\rangle$
882 }{6foob1baz327z}
883 \end{doclatex}
884
885 Encadrement de \verb|\alpha| et \verb|\beta| avec leur coefficient en mode mathématique :
886 \begin{doclatex}
887 \fboxsep=1pt
888 \pegreplace{ \r{1-9}* : \S{\alpha\beta} -> \fbox{\strut$\0$} }{$2\alpha-3\beta=-4-\alpha+4\beta$}
889 \end{doclatex}
890
891 On créé une grammaire qui matche avec le code postal et le nom d'une ville (composé de mots et de tirets).
892 \begin{doclatex}
893 \defpattern\sp{ \R{*:10} }
894 \defpattern\CP{\c\r{0-9}^2 : \sp? : \c\r{0-9}^3 }% \1=2 premiers chiffres \2=3 derniers
895 \defpattern\upcase{ \r{A-Z,À,É} }
896 \defpattern\lowcase{ \r{a-z,é,è,à,ê,ô,ç} }
897 \defpattern\ville{ \upcase : \lowcase+ : { \S{-} : {\upcase | \lowcase} : \lowcase+ }* }
898 \defpattern\CPville{ \CP : \sp : \c\ville }% capturer CP et capturer Ville
899 1) \pegreplace{\CPville -> CodePostal=\textbf{\1\2} est \fbox{\3} }{Destination 75000 Paris}\par
900 2) \pegreplace{\CPville -> CodePostal=\textbf{\1\2} est \fbox{\3} }{Destination 64 500 Saint-Jean-de-Luz suite}\par
901 3) \pegreplace{\CPville -> CodePostal=\textbf{\1\2} est \fbox{\3} }{Destination 38120 Saint-Égrève}
902 \end{doclatex}
903
904 Crée une petite devinette concernant des nombres ayant de 2 chiffres non nuls :
905 \begin{doclatex}
906 \defpattern\num{ \c\r{1-9} : \c\r{1-9} : !\r{0-9} }
907 Si \pegreplace{\num -> \1\2 donne \the\numexpr\1*\2+\2\relax }{27, 34 et 43}, que donne 57 ? (Répondez dans 7,5~millions d'années)
908 \end{doclatex}
909
910 \section{Erreurs}
911 Parmi les nombreuses erreurs qui peuvent se produire, en voici quelques unes...
912
913 \subsection{Accolades non équilibrées}
914 Si un résultat ou une capture est constitué de tokens dont les accolades ne sont pas équilibrées, une erreur de compilation se produira.
915
916 Par exemple, si à l'aide de \verb|\toksdo|, on supprime les accolades fermantes :
917 \tktlcode/\toksdo{ \R{*:2} -&> \deltok }{foo{\bfseries123}bar}/
918 l'erreur émise par \tktl est «\texttt{! Unbalanced open-group token, 1 close-group token added}».
919
920 Pour équilibrer les accolades, une accolade fermante est donc rajoutée à la fin des tokens passés en argument et les tokens «\verb|foo{\bfseries123bar}|» sont dirigés vers l'affichage.
921
922 De la même façon, si on supprime les accolades ouvrantes :
923 \tktlcode/\toksdo{ \R{*:1} -&> \deltok}{foo{\bfseries123}bar}/
924 l'erreur émise est «\texttt{! Unbalanced close-group token ignored}».
925
926 L'accolade fermante en sur-nombre est donc ignorée et les tokens «\verb|foo\bfseries123bar|» sont dirigés vers l'affichage
927
928 \subsection{Moteur non adapté}
929 L'utilisation d'un moteur 8~bits \emph{impose} de n'utiliser que des tokens, notamment pour le marqueur \verb|\r|.
930
931 Compiler ce code avec un moteur 8~bits
932 \tktlcode/\ifpegmatch{ \r{a,e,i,o,u,y,é,à,ê,ù} }{Un été à l'océan}{V}{F}/
933 provoque une erreur de compilation car «\verb|é|» est constitué de 2 tokens (charcodes 195 et 169, catcodes égaux à 13) alors que la syntaxe de \verb|\r| impose qu'il n'y en ait qu'un. L'erreur de compilation émaise par \tktl est «\texttt{! Multiple token 'é', '0' inserted}».
934
935 La syntaxe correcte serait
936 \tktlcode/\ifpegmatch{ \r{a,e,i,o,u,y} | \S{éàêù} }{Un été à l'océan}{V}{F}/
937
938 \subsection{Intervalle incorrect}
939 Les intervalles de la forme \verb|<a>-<b>|, que \verb|a| et \verb|b| soit des tokens ou des nombres \emph{doivent} être mis dans l'odre.
940
941 Comme le token «ń» vient \emph{après} «ó» en UTF8, le code
942 \tktlcode/\ifpegmatch{ \r{ń-ó} }{Un texte quelconque}{V}{F}/
943 provoque l'erreur de compilation «\texttt{! Unsorted interval 'ń-ó', 'ó-ń' inserted}». L'intervalle est corrigé par \tktl.
944
945 \subsection{Syntaxe de motif non respectée}
946 Espaces mis à part car ils sont ignorés, toute syntaxe de motif non conforme à ce qui a été décrit à partir de la page~\pageref{motifs} provoque une erreur de compilation.
947
948 Par exemple
949 \tktlcode/\pegcount{ \r{a-z} | S{10} }{ab1023truc098}/
950 provoque l'erreur «\texttt{! Found "S" when expecting \string\r, \string\R, \string\s, \string\S\space or \string\.}».
951
952 \subsection{Erreurs de capture}
953 Si un \<nom> n'a pas été défini ou si un \<index> est demandé hors de ceux assignés lors des captures, une erreur de compilation est renvoyée.
954
955 \tktlcode/\pegcount{ \r{a-z}^2 }{ab1023truc098}/
956 crée 3 captures et donc demander
957 \tktlcode/\tokscapture{4}/
958 envoie l'erreur de compilation «\texttt{! Undefined token capture at index "4"}».
959
960 \section{Listes des macros et marqueurs}
961 \subsection{Liste des commandes}
962 Voici les macros mises à disposition de l'utilisateur :
963 \begin{itemize}
964 \item \verb|\printtoks|, voir page~\pageref{printtoks};
965 \item \verb|\toksdo|, \verb|\setcharcode|, \verb|\setcatcode|, \verb|\deltok|, \verb|\addtok|, \verb|\selfcharcode|, \verb|\selfcatcode| et \verb|\selfindex|, voir pages~\pageref{toksdo} et suivantes;
966 \item \verb|\tokscount|, voir page~\pageref{tokscount};
967 \item \verb|\defpattern|, voir page~\pageref{defpattern};
968 \item \verb|\ifpegmatch|, voir page~\pageref{ifpegmatch};
969 \item \verb|\pegcount|, voir page~\pageref{pegcount};
970 \item \verb|\pegreplace|, voir page~\pageref{pegreplace}.
971 \end{itemize}
972 Les macros suivantes sont modifiées par la macro \verb|\toksdo|, mais sont cependant restaurées à leur état antérieur après la fin de l'exécution de \verb|\toksdo| :
973 \verb|\setcharcode|, \verb|\setcatcode|, \verb|\deltok|, \verb|\addtok|, \verb|\selfcharcode|, \verb|\selfcatcode| et \verb|\selfindex|.
974
975 \subsection{Liste des marqueurs}
976 \begin{itemize}[topsep=0pt]
977 \item\verb|\r{<csv car>:<csv catcode>}|, voir page~\pageref{motif:r};
978 \item\verb|\R{<csv charcodes>:<csv catcode>}|, voir page~\pageref{motif:R};
979 \item\verb|\s{<tokens>}|, voir page~\pageref{motif:s};
980 \item\verb|\S{<tokens>}|, voir page~\pageref{motif:S};
981 \item\verb|\.|, voir page~\pageref{motif:dot};
982 \item\verb|\c| peut avoir la syntaxe
983 \begin{itemize}[label={}]
984 \item \verb|\c{<catcode>}{<tokens>}| lorsque utilisé dans l'argument de \verb|\s| ou \verb|\S|, voir page~\pageref{marqueur:c:catcode};
985 \item \verb|\c| lorsque placé avant ou après un \<1-motif>, voir page~\pageref{marqueur:c:capture};
986 \end{itemize}
987 \item\verb|\self|, voir page~\pageref{marqueur:self};
988 \item \verb|\0|, \verb|\1| jusqu'à \verb|\9|, voir page~\pageref{marqueur:0};
989 \item toute \<macro>, existante ou non, passée en premier argument de \verb|\defpattern|.
990 \end{itemize}
991
992 \begin{center}
993 \parskip0pt
994 $\star$\par
995 $\star\quad\star$
996 \end{center}
997
998 Ce package en version \tktlver{} se trouve encore à un stade expérimental et il se peut que, malgré les tests qui ont été faits, il contienne de nombreux bugs.
999
1000 Par ailleurs, certaines fonctionnalités ou syntaxes sont encore susceptible d'évoluer à la marge.
1001
1002 Quoiqu'il en soit, j'espère que \tktl vous est utile. N'hésitez pas à me contacter par \href{mailto:[email protected]}{\texttt{\textbf{email}}} pour me faire part de bugs, dysfonctionnements ou suggestions de fonctionnalités \emph{réalistes} et surtout, ne perdez pas votre temps à le faire sur \verb|https://tex.stackexchange.com| ou tout autre site, vu qu'il est très probable que je n'en prenne pas connaissance.
1003 \end{document}