<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;">% !TeX TS-program = lualatex
\documentclass[a4paper,10pt,french]{article}
\usepackage{fontspec}
\usepackage[bookmarks=true,bookmarksopen=true,colorlinks=true,hyperfootnotes=false,filecolor=black,linkcolor=blue,urlcolor=blue,pdfauthor={Christian Tellechea},pdftitle={xstring},pdfsubject={package pour la manipulation de chaines de tokens},pdfkeywords={xstring,latex,tex,string,chaine},pdfcreator={LaTeX}]{hyperref}
\usepackage[margin=1.9cm]{geometry}
\usepackage{libertine}
\usepackage[scale=0.85]{noto-mono}
\usepackage[bottom]{footmisc}
\usepackage{amsmath,amssymb,amsfonts,xcolor,eurosym,xspace,xstring,babel}
\makeatletter
\newcommand\make@car@active[1]{%
	\catcode`#1\active
	\begingroup
		\lccode`\~`#1\relax
		\lowercase{\endgroup\def~}%
}

\newcount\code@line
\newbox\box@code
\newbox\box@exec
\newbox\box@bkgd

\newcommand*\showcode{%
	\begingroup
	\parskip\z@
	\parindent\z@
	\code@line\z@
	\@makeother\;\@makeother\!\@makeother\?\@makeother\:
	\medbreak
	\noindent
	\begingroup
		\let\do\@makeother\dospecials
		\make@car@active\ { }%
		\make@car@active\^^M{\par\leavevmode}%
		\make@car@active\^^I{\space\space\space\space}%
		\make@car@active\,{\leavevmode\kern\z@\string,}%
		\make@car@active\-{\leavevmode\kern\z@\string-}%
		\showcode@a
}

\newcommand\showcode@a[2][65]{%
		\def\@tempa##1#2{%
			\xdef\the@code{##1}%
		\endgroup
		\showcode@b{#1}{##1}}%
	\@tempa}

\newcommand\showcode@b[2]{%
	\vskip0.5ex
	\fboxsep5pt
	\setbox\box@code=\hbox{%
		$\vcenter{
			\hsize\dimexpr0.#1\linewidth-\fboxsep-\fboxrule\relax
			\parskip0pt
			\ttfamily
			\small
			\everypar{\llap{\global\advance\code@line\@ne\tiny\number\code@line\kern\dimexpr\fboxsep+3pt }}%
			\the@code\par
		}$%
	}%
	\setbox\box@exec=\hbox{%
		$\vcenter{
			\hsize\dimexpr\linewidth-0.#1\linewidth-\fboxsep-\fboxrule\relax
			\small
			\newlinechar`\^^M\everyeof{\noexpand}%
			\scantokens{#2}%
		}$%
	}%
	\fbox{%
		\begingroup
			\color{black!15}%
			\setbox\box@bkgd=\hbox{% fond code
				\vrule width\wd\box@code
				       height\dimexpr\max@dim{\ht\box@code}{\ht\box@exec}+\fboxsep\relax
				       depth \dimexpr\max@dim{\dp\box@code}{\dp\box@exec}+\fboxsep\relax
			}%
			\wd\box@bkgd=0pt \ht\box@bkgd=0pt \dp\box@bkgd=0pt
			\kern-\fboxsep
			\box\box@bkgd
			\kern\fboxsep
		\endgroup
		\setbox\box@bkgd=\hbox{% rÃ©glure verticale
			\vrule width.5pt
			       height\dimexpr\max@dim{\ht\box@code}{\ht\box@exec}+\fboxsep\relax
			       depth \dimexpr\max@dim{\dp\box@code}{\dp\box@exec}+\fboxsep\relax
		}%
		\box\box@code
		\wd\box@bkgd=0pt \ht\box@bkgd=0pt \dp\box@bkgd=0pt
		\kern-\fboxsep
		\box\box@bkgd
		\kern\fboxsep
		\box\box@exec
	}%
	\medbreak
	\endgroup
}
\def\max@dim#1#2{\ifdim#1&gt;#2 #1\else#2\fi}

\definecolor{violet}{rgb}{0.66,0,0.66}
\makeatother

\newcommand\guill[1]{\og{}#1\fg{}}
\newcommand\argu[1]{$\langle$\textit{#1}$\rangle$}
\newcommand\ARGU[1]{\texttt{\color{black}\{}\argu{#1}\texttt{\color{black}\}}}
\newcommand\arguC[1]{\texttt{\color{black}[}\argu{#1}\texttt{\color{black}]}}
\newcommand\arguCC[2]{\texttt{\color{black}[}\argu{#1}\texttt{\color{black},}\argu{#2}\texttt{\color{black}]}}
\newcommand\texte[1]{\texttt{text}${}_{#1}$}
\newcommand\etoile{$\langle$\texttt{[*]}$\rangle$}
\newenvironment{Conditions}[1][1cm]%
{\begin{list}%
	{$\vartriangleright$}%
	{\setlength{\leftmargin}{#1}
	 \setlength{\itemsep}{0pt}
	 \setlength{\parsep}{0pt}
	 \setlength{\topsep}{2ptplus3ptminus2pt}
	}}%
{\end{list}}

\newcommand\US{unitÃ© syntaxique\xspace}
\newcommand\USs{unitÃ©s syntaxiques\xspace}
\newcommand\Xstring{\textsf{xstring}\xspace}
\newcommand\styleexemple{\small\vskip.4\baselineskip\relax}
\newcommand\styleexercice{\footnotesize}
\newcommand\colorise{\color{violet}}
\def\xstringfrenchdateaux#1/#2/#3\nil{\number#3\relax\ifnum#3=1 \noexpand\ier\fi\space \ifcase #2 \or janvier\or f\'evrier\or mars\or avril\or mai\or juin\or juillet\or aout\or septembre\or octobre\or novembre\or d\'ecembre\fi\space#1}
\edef\xstringfrenchdate{\expandafter\xstringfrenchdateaux\xstringdate\nil}
\begin{document}
\setlength{\parindent}{0pt}
\begin{titlepage}
	\null\par\vfill
	\begin{center}
		\begin{minipage}{0.75\linewidth}
			\begin{center}
				\Huge\bfseries \Xstring\par\vspace{5pt}
				\small v\xstringversion\par\vspace{25pt}
				\normalsize Manuel de l'utilisateur
			\end{center}
		\end{minipage}
	\end{center}
	\vspace{1cm}
	\begin{center}
		Christian {\sc Tellechea}\par\small
		\href{mailto:unbonpetit@netc.fr}{\nolinkurl{unbonpetit@netc.fr}}\par\vspace{5pt}
		\xstringfrenchdate
	\end{center}
	\vfill\hrulefill
	\begin{center}
		\begin{minipage}{0.85\linewidth}
			\noindent
			\hfill\textbf{\textit{RÃ©sumÃ©}}\hfill{}\medskip\par
			Cette extension fournit un ensemble de macros manipulant des chaÃ®nes de tokens. Les macros, non dÃ©veloppables, peuvent Ãªtre utilisÃ©es de faÃ§on basique dans le traitement des chaÃ®nes de caractÃ¨res mais peuvent Ã©galement Ãªtre utiles en programmation \TeX{} pour la manipulation des tokens, c'est-Ã&nbsp;-dire du code \TeX{}.
		\end{minipage}
	\end{center}
	\hrulefill\vfill{}
\end{titlepage}

\tableofcontents

%
\section{PrÃ©sentation}
Cette extension\footnote{L'extension ne nÃ©cessite pas \LaTeX{} et peut Ãªtre compilÃ©e sous Plain $\varepsilon$-\TeX{}.} regroupe des macros et des tests non dÃ©veloppables opÃ©rant sur des chaÃ®nes de tokens, un peu comme en disposent des langages dit \guill{Ã©voluÃ©s}. On y trouve les opÃ©rations habituelles sur les chaÃ®nes, comme par exemple : test si une chaÃ®ne en contient une autre, commence ou finit par une autre, test si une chaÃ®ne est un nombre entier ou dÃ©cimal, extractions de sous-chaÃ®nes, calculs de position d'une sous-chaÃ®ne, calculs du nombre d'occurrences, etc.\medskip

On appelle \guill{chaÃ®ne de tokens} une suite de tokens quelconques, sachant qu'aucune supposition n'a Ã©tÃ© faite quant Ã&nbsp; leur nature, mis Ã&nbsp; part que dans les chaÃ®nes de tokens, les accolades doivent Ãªtre Ã©quilibrÃ©es et que les tokens de catcode 6 et 14 (habituellement \verb|%| et \verb|#|) n'y sont pas admis. Tous les autres tokens, y compris \verb|\par|, sont \emph{Ã&nbsp; priori} permis dans n'importe quel ordre, quel que soit le code qu'ils reprÃ©sentent.\medskip

Les arguments contenant des chaÃ®nes de tokens sont lus par \Xstring \emph{\US par \US\footnote{Sauf cas particulier, une \US est un caractÃ¨re lu dans le code Ã&nbsp; ces exceptions prÃ¨s : une sÃ©quence de contrÃ´le est une \US, un groupe entre accolades est aussi une \US. Voir Ã©galement page~\pageref{developpementarguments}.}}, ce qui revient Ã&nbsp; les lire caractÃ¨re par caractÃ¨re lorsque ceux-ci contiennent des tokens \guill{normaux}, c'est-Ã&nbsp;-dire dont les catcodes sont 10, 11 et 12. On peut Ã©galement utiliser \Xstring Ã&nbsp; des fins de programmation en utilisant des arguments contenant des sÃ©quences de contrÃ´le et des tokens dont les catcodes sont moins inoffensifs. Voir le chapitre sur le mode de lecture et de dÃ©veloppement des arguments (page~\pageref{developpementarguments}), la commande \verb|\verbtocs| (page~\pageref{verbtocs}), la commande \verb|\scancs| (page~\pageref{scancs}).\medskip

Certes d'autres packages manipulant les chaÃ®nes de caractÃ¨res existent (par exemple \href{http://mirror.ctan.org/tex-archive/macros/latex/contrib/substr/}{\nolinkurl{substr}} et \href{http://mirror.ctan.org/tex-archive/macros/latex/contrib/stringstrings/}{\nolinkurl{stringstrings}}), mais outre des diffÃ©rences notables quant aux fonctionnalitÃ©s, ils ne prennent pas en charge les occurrences des sous-chaÃ®nes et me semblent soit trop limitÃ©s, soit trop difficiles Ã&nbsp; utiliser pour la programmation.\medskip

Comme les macros manipulent des chaÃ®nes de tokens, il peut arriver aux utilisateurs avancÃ©s de rencontrer des problÃ¨mes de \guill{catcodes\footnote{Codes de catÃ©gories, en franÃ§ais.}} conduisant Ã&nbsp; des comportements inattendus. Ces effets indÃ©sirables peuvent Ãªtre contrÃ´lÃ©s. Consulter en particulier le chapitre sur les catcodes des arguments page~\pageref{macrosetoilees}.

\section{Les macros}
Pour bien comprendre les actions de chaque macro, envisageons tout d'abord le fonctionnement et la prÃ©sentation des macros dans leur mode de fonctionnement le plus simple. Pas de problÃ¨me de catcode ici, ni de tokens spÃ©ciaux et encore moins de sÃ©quence de contrÃ´le dans les arguments : les arguments contiendront des caractÃ¨res alphanumÃ©riques.\medskip

Dans ce chapitre, la totalitÃ© des macros est prÃ©sentÃ©e selon ce plan :\par\nobreak\smallskip\parindent3em
\begin{itemize}
	\item la syntaxe complÃ¨te\footnote{L'Ã©toile optionnelle aprÃ¨s le nom de la macro, et l'argument optionnel entre crochet venant en dernier seront expliquÃ©s plus tard. Voir page~\pageref{macrosetoilees} pour les macros Ã©toilÃ©es et page~\pageref{argumentoptionnel} pour l'argument optionnel en derniÃ¨re position.} ainsi que la valeur d'Ã©ventuels arguments optionnels;
	\item une brÃ¨ve description du fonctionnement;
	\item le fonctionnement sous certaines conditions particuliÃ¨res. Pour chaque conditions envisagÃ©e, le fonctionnement dÃ©crit est prioritaire sur celui (ceux) se trouvant au dessous de lui;
	\item enfin, quelques exemples sont donnÃ©s. J'ai essayÃ© de les trouver les plus facilement comprÃ©hensibles et les plus reprÃ©sentatifs des situations rencontrÃ©es dans une utilisation normale\footnote{Pour une collection plus importante d'exemples, on peut aussi consulter le fichier de test.}. Si un doute est possible quant Ã&nbsp; la prÃ©sence d'espaces dans le rÃ©sultat, celui-ci sera dÃ©limitÃ© par des \guill{\textbar}, Ã©tant entendu qu'une chaÃ®ne vide est reprÃ©sentÃ©e par \guill{\textbar\textbar}.
\end{itemize}\parindent0pt\smallskip

\textbf{Important} : dans les macros qui suivent, sauf cas spÃ©cifiÃ©, un \argu{nombre} est un nombre entier, un compteur, ou le rÃ©sultat d'une opÃ©ration arithmÃ©tique effectuÃ©e Ã&nbsp; l'aide de la primitive \verb|\numexpr|.

\subsection{Les tests}
\subsubsection{\ttfamily\textbackslash IfSubStr}
\verb|\IfSubStr|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
\smallskip

L'argument optionnel \argu{nombre} vaut 1 par dÃ©faut.\par\nobreak\smallskip

Teste si \argu{chaine} contient au moins \argu{nombre} fois \argu{chaineA} et exÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip

\begin{Conditions}
	\item Si \argu{nombre}${}\leqslant0$,  exÃ©cute \argu{faux};
	\item Si \argu{chaine} ou \argu{chaineA} est vide, exÃ©cute \argu{faux}.
\end{Conditions}

\showcode|\IfSubStr{xstring}{tri}{vrai}{faux}\par
\IfSubStr{xstring}{a}{vrai}{faux}\par
\IfSubStr{a bc def }{c d}{vrai}{faux}\par
\IfSubStr{a bc def }{cd}{vrai}{faux}\par
\IfSubStr[2]{1a2a3a}{a}{vrai}{faux}\par
\IfSubStr[3]{1a2a3a}{a}{vrai}{faux}\par
\IfSubStr[4]{1a2a3a}{a}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfSubStrBefore}
\verb|\IfSubStrBefore|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
\smallskip

Les arguments optionnels \argu{nombre1} et \argu{nombre2} valent 1 par dÃ©faut.\par\nobreak\smallskip

Dans \argu{chaine}, la macro teste si l'occurrence \no\argu{nombre1} de \argu{chaineA} se trouve Ã&nbsp; gauche de l'occurrence \no\argu{nombre2} de \argu{chaineB}. ExÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip

\begin{Conditions}
	\item Si l'une des occurrences n'est pas trouvÃ©e, exÃ©cute \argu{faux};
	\item Si l'un des arguments \argu{chaine}, \argu{chaineA} ou \argu{chaineB} est vide, exÃ©cute \argu{faux};
	\item Si l'un au moins des deux arguments optionnels est nÃ©gatif ou nul, exÃ©cute \argu{faux}.
\end{Conditions}

\showcode|\IfSubStrBefore{xstring}{st}{in}{vrai}{faux}\par
\IfSubStrBefore{xstring}{ri}{s}{vrai}{faux}\par
\IfSubStrBefore{LaTeX}{LaT}{TeX}{vrai}{faux}\par
\IfSubStrBefore{a bc def }{ b}{ef}{vrai}{faux}\par
\IfSubStrBefore{a bc def }{ab}{ef}{vrai}{faux}\par
\IfSubStrBefore[2,1]{b1b2b3}{b}{2}{vrai}{faux}\par
\IfSubStrBefore[3,1]{b1b2b3}{b}{2}{vrai}{faux}\par
\IfSubStrBefore[2,2]{baobab}{a}{b}{vrai}{faux}\par
\IfSubStrBefore[2,3]{baobab}{a}{b}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfSubStrBehind}
\verb|\IfSubStrBehind|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
\smallskip

Les arguments optionnels \argu{nombre1} et \argu{nombre2} valent 1 par dÃ©faut.\par\nobreak\smallskip

Dans \argu{chaine}, la macro teste si l'occurrence \no\argu{nombre1} de \argu{chaineA} se trouve aprÃ¨s l'occurrence \\\no\argu{nombre2} de \argu{chaineB}. ExÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip

\begin{Conditions}
	\item Si l'une des occurrences n'est pas trouvÃ©e, exÃ©cute \argu{faux};
	\item Si l'un des arguments \argu{chaine}, \argu{chaineA} ou \argu{chaineB} est vide, exÃ©cute \argu{faux};
	\item Si l'un au moins des deux arguments optionnels est nÃ©gatif ou nul, exÃ©cute \argu{faux}.
\end{Conditions}

\showcode|\IfSubStrBehind{xstring}{ri}{xs}{vrai}{faux}\par
\IfSubStrBehind{xstring}{s}{i}{vrai}{faux}\par
\IfSubStrBehind{LaTeX}{TeX}{LaT}{vrai}{faux}\par
\IfSubStrBehind{a bc def }{ d}{a}{vrai}{faux}\par
\IfSubStrBehind{a bc def }{cd}{a b}{vrai}{faux}\par
\IfSubStrBehind[2,1]{b1b2b3}{b}{2}{vrai}{faux}\par
\IfSubStrBehind[3,1]{b1b2b3}{b}{2}{vrai}{faux}\par
\IfSubStrBehind[2,2]{baobab}{b}{a}{vrai}{faux}\par
\IfSubStrBehind[2,3]{baobab}{b}{a}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfBeginWith}
\verb|\IfBeginWith|\etoile\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
\smallskip

Teste si \argu{chaine} commence par \argu{chaineA}, et exÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip

\begin{Conditions}
\item Si \argu{chaine} ou \argu{chaineA} est vide, exÃ©cute \argu{faux}.
\end{Conditions}

\showcode|\IfBeginWith{xstring}{xst}{vrai}{faux}\par
\IfBeginWith{LaTeX}{a}{vrai}{faux}\par
\IfBeginWith{a bc def }{a b}{vrai}{faux}\par
\IfBeginWith{a bc def }{ab}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfEndWith}
\verb|\IfEndWith|\etoile\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
\smallskip

Teste si \argu{chaine} se termine par \argu{chaineA}, et exÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip

\begin{Conditions}
	\item Si \argu{chaine} ou \argu{chaineA} est vide, exÃ©cute \argu{faux}.
\end{Conditions}

\showcode|\IfEndWith{xstring}{ring}{vrai}{faux}\par
\IfEndWith{LaTeX}{a}{vrai}{faux}\par
\IfEndWith{a bc def }{ef }{vrai}{faux}\par
\IfEndWith{a bc def }{ef}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfInteger}
\verb|\IfInteger|\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
\smallskip

Teste si \argu{nombre} est un nombre entier relatif (c'est-Ã&nbsp;-dire dont la partie dÃ©cimale est absente ou constituÃ©e d'une suite de 0), et exÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\par\nobreak\smallskip

Si le test est faux pour cause de caractÃ¨res non autorisÃ©s, \verb|\afterinteger| contient la partie illÃ©gale de \argu{nombre}.\medskip

\showcode|\IfInteger{13}{vrai}{faux}\par
\IfInteger{-219}{vrai}{faux}\par
\IfInteger{+9}{vrai}{faux}\par
\IfInteger{3.14}{vrai}{faux}\par
\IfInteger{8.0}{vrai}{faux}\par
\IfInteger{0}{vrai}{faux}\par
\IfInteger{49a}{vrai}{faux}\par
\IfInteger{+}{vrai}{faux}\par
\IfInteger{-}{vrai}{faux}\par
\IfInteger{0000}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfDecimal}\label{ifdecimal}
\verb|\IfDecimal|\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
\smallskip

Teste si \argu{nombre} est un nombre dÃ©cimal, et exÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\par\nobreak\smallskip

Les macros \verb|\integerpart| et \verb|\decimalpart| contiennent les parties entiÃ¨res et dÃ©cimales de \argu{nombre}.

Si le test est faux pour cause de caractÃ¨res non autorisÃ©s, \verb|\afterdecimal| contient la partie illÃ©gale de \argu{nombre}, alors que si le test est faux parce que la partie dÃ©cimale aprÃ¨s le sÃ©parateur dÃ©cimal est vide, elle contient \guill{X}.\medskip

\begin{Conditions}
	\item Le sÃ©parateur dÃ©cimal peut Ãªtre un point ou une virgule;
	\item Si le \argu{nombre} commence par un sÃ©parateur dÃ©cimal, le test est vrai (lignes 4 et 5) et la partie entiÃ¨re est considÃ©rÃ©e comme Ã©tant 0;
	\item Si le \argu{nombre} se termine par un sÃ©parateur dÃ©cimal, le test est faux (lignes 9 et 10).
\end{Conditions}

\showcode|\IfDecimal{3.14}{vrai}{faux}\par
\IfDecimal{3,14}{vrai}{faux}\par
\IfDecimal{-0.5}{vrai}{faux}\par
\IfDecimal{.7}{vrai}{faux}\par
\IfDecimal{,9}{vrai}{faux}\par
\IfDecimal{1..2}{vrai}{faux}\par
\IfDecimal{+6}{vrai}{faux}\par
\IfDecimal{-15}{vrai}{faux}\par
\IfDecimal{1.}{vrai}{faux}\par
\IfDecimal{2,}{vrai}{faux}\par
\IfDecimal{.}{vrai}{faux}\par
\IfDecimal{,}{vrai}{faux}\par
\IfDecimal{+}{vrai}{faux}\par
\IfDecimal{-}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfStrEq}
\verb|\IfStrEq|\etoile\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
\smallskip

Teste si les chaÃ®nes \argu{chaineA} et \argu{chaineB} sont Ã©gales, c'est-Ã&nbsp;-dire si elles contiennent successivement les mÃªmes \US dans le mÃªme ordre. ExÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\smallskip

\showcode|\IfStrEq{a1b2c3}{a1b2c3}{vrai}{faux}\par
\IfStrEq{abcdef}{abcd}{vrai}{faux}\par
\IfStrEq{abc}{abcdef}{vrai}{faux}\par
\IfStrEq{3,14}{3,14}{vrai}{faux}\par
\IfStrEq{12.34}{12.340}{vrai}{faux}\par
\IfStrEq{abc}{}{vrai}{faux}\par
\IfStrEq{}{abc}{vrai}{faux}\par
\IfStrEq{}{}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfEq}
\verb|\IfEq|\etoile\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
\smallskip

Teste si les chaÃ®nes \argu{chaineA} et \argu{chaineB} sont Ã©gales, \emph{sauf} si \argu{chaineA} et \argu{chaineB} contiennent des nombres, auquel cas la macro teste si les nombres sont Ã©gaux. ExÃ©cute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\smallskip

\begin{Conditions}
	\item La dÃ©finition de \emph{nombre} est celle Ã©voquÃ©e dans la macro \verb|\IfDecimal| (voir page~\pageref{ifdecimal}), et donc :
	\item Les signes \guill{+} sont facultatifs;
	\item Le sÃ©parateur dÃ©cimal peut Ãªtre indiffÃ©remment la virgule ou le point.
\end{Conditions}

\showcode|\IfEq{a1b2c3}{a1b2c3}{vrai}{faux}\par
\IfEq{abcdef}{ab}{vrai}{faux}\par
\IfEq{ab}{abcdef}{vrai}{faux}\par
\IfEq{12.34}{12,34}{vrai}{faux}\par
\IfEq{+12.34}{12.340}{vrai}{faux}\par
\IfEq{10}{+10}{vrai}{faux}\par
\IfEq{-10}{10}{vrai}{faux}\par
\IfEq{+0,5}{,5}{vrai}{faux}\par
\IfEq{1.001}{1.01}{vrai}{faux}\par
\IfEq{3*4+2}{14}{vrai}{faux}\par
\IfEq{\number\numexpr3*4+2}{14}{vrai}{faux}\par
\IfEq{0}{-0.0}{vrai}{faux}\par
\IfEq{}{}{vrai}{faux}|

\subsubsection{\ttfamily\textbackslash IfStrEqCase}
\begin{minipage}{\textwidth}
	\verb|\IfStrEqCase|\etoile\ARGU{chaine}\verb|{%|\par
	\qquad\qquad\ARGU{chaine1}\ARGU{code1}\verb|%|\par
	\qquad\qquad\ARGU{chaine2}\ARGU{code2}\verb|%|\par
	\qquad\qquad\verb|etc...|\par
	\qquad\qquad\ARGU{chaineN}\ARGU{codeN}\verb|}|\arguC{code alternatif}
\end{minipage}
\smallskip

Teste successivement si \argu{chaine} est Ã©gale Ã&nbsp; \argu{chaine1}, \argu{chaine2}, etc. La comparaison se fait au sens de \verb|\IfStrEq| (voir paragraphes prÃ©cÃ©dents). Si un test est positif, le code correspondant est exÃ©cutÃ© et la macro se termine. Si tous les tests sont nÃ©gatifs, le code optionnel \argu{code alternatif} est exÃ©cutÃ© s'il est prÃ©sent.\smallskip

\showcode-\IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
|\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
\IfStrEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
\IfStrEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
\IfStrEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]\par
\IfStrEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]-

\subsubsection{\ttfamily\textbackslash IfEqCase}
\begin{minipage}{\textwidth}
	\verb|\IfEqCase|\etoile\ARGU{chaine}\verb|{%|\par
	\qquad\qquad\ARGU{chaine1}\ARGU{code1}\verb|%|\par
	\qquad\qquad\ARGU{chaine2}\ARGU{code2}\verb|%|\par
	\qquad\qquad\verb|etc...|\par
	\qquad\qquad\ARGU{chaineN}\ARGU{codeN}\verb|}|\arguC{code alternatif}
\end{minipage}
\smallskip

Teste successivement si \argu{chaine} est Ã©gale Ã&nbsp; \argu{chaine1}, \argu{chaine2}, etc. La comparaison se fait au sens de \verb|\IfEq| (voir paragraphes prÃ©cÃ©dents). Si un test est positif, le code correspondant est exÃ©cutÃ© et la macro se termine. Si tous les tests sont nÃ©gatifs, le code optionnel \argu{code alternatif} est exÃ©cutÃ© s'il est prÃ©sent.\smallskip

\showcode-\IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
|\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
\IfEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
\IfEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
\IfEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]\par
\IfEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]-

\subsection{Les macros renvoyant une chaÃ®ne}
\subsubsection{\ttfamily\textbackslash StrBefore}
\verb|\StrBefore|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
\smallskip

L'argument optionnel \argu{nombre} vaut 1 par dÃ©faut.\par\nobreak\smallskip

Dans \argu{chaine}, renvoie ce qui se trouve avant l'occurrence \no\argu{nombre} de \argu{chaineA}.\medskip

\begin{Conditions}
	\item Si \argu{chaine} ou \argu{chaineA} est vide, une chaÃ®ne vide est renvoyÃ©e;
	\item Si \argu{nombre}${}&lt;1$ alors, la macro se comporte comme si \argu{nombre}${}=1$;
	\item Si l'occurrence n'est pas trouvÃ©e, une chaÃ®ne vide est renvoyÃ©e.
\end{Conditions}

\showcode-\StrBefore{xstring}{tri}\par
\StrBefore{LaTeX}{e}\par
|\StrBefore{LaTeX}{p}|\par
|\StrBefore{LaTeX}{L}|\par
|\StrBefore{a bc def }{def}|\par
|\StrBefore{a bc def }{cd}|\par
\StrBefore[1]{1b2b3}{b}\par
\StrBefore[2]{1b2b3}{b}-

\subsubsection{\ttfamily\textbackslash StrBehind}
\verb|\StrBehind|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
\smallskip

L'argument optionnel \argu{nombre} vaut 1 par dÃ©faut.\par\nobreak\smallskip

Dans \argu{chaine}, renvoie ce qui se trouve aprÃ¨s l'occurrence \no\argu{nombre} de \argu{chaineA}.\medskip

\begin{Conditions}
	\item Si \argu{chaine} ou \argu{chaineA} est vide, une chaÃ®ne vide est renvoyÃ©e;
	\item Si \argu{nombre}${}&lt;1$ alors, la macro se comporte comme si \argu{nombre}${}=1$;
	\item Si l'occurrence n'est pas trouvÃ©e, une chaÃ®ne vide est renvoyÃ©e.
\end{Conditions}

\showcode-\StrBehind{xstring}{tri}\par
\StrBehind{LaTeX}{e}\par
|\StrBehind{LaTeX}{p}|\par
|\StrBehind{LaTeX}{X}|\par
|\StrBehind{a bc def }{bc}|\par
|\StrBehind{a bc def }{cd}|\par
\StrBehind[1]{1b2b3}{b}\par
\StrBehind[2]{1b2b3}{b}\par
|\StrBehind[3]{1b2b3}{b}-

\subsubsection{\ttfamily\textbackslash StrCut}
Voici la syntaxe de cette macro :\par\nobreak\smallskip
\verb|\StrCut|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{macroA}\ARGU{macroB}
\smallskip

L'argument optionnel \argu{nombre} vaut 1 par dÃ©faut.\par\nobreak\smallskip
La \argu{chaine} est coupÃ©e en deux chaÃ®nes Ã&nbsp; l'occurrence \no\arguC{nombre} de la \ARGU{chaineA}. Ce qui se trouve Ã&nbsp; gauche de cette occurrence est assignÃ© Ã&nbsp; la sÃ©quence de contrÃ´le \argu{macroA} et ce qui se trouve Ã&nbsp; droite Ã&nbsp; \argu{macroB}.

Cette macro renvoie \emph{deux chaÃ®nes} et donc \textbf{n'affiche rien}. Par consÃ©quent, elle ne dispose pas de l'argument optionnel en derniÃ¨re position.\medskip

\begin{Conditions}
	\item Si \argu{chaine} ou \argu{chaineA} est vide, \argu{macroA} et\argu{macroB} seront vides ;
	\item Si \argu{nombre}${}&lt;1$ alors, la macro se comporte comme si \argu{nombre}${}=1$;
	\item Si l'occurrence n'est pas trouvÃ©e, \argu{macroA} reÃ§oit la totalitÃ© de \argu{chaine} tandis que \argu{macroB} est vide.
\end{Conditions}

\showcode+\def\seprouge{{\color{red}|}}
\StrCut{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
\StrCut[2]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
\StrCut[3]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
\StrCut[4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
\StrCut[5]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
\StrCut[6]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
\StrCut[-4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
\StrCut{abracadabra}{brac}\csA\csB |\csA\seprouge\csB|\par
\StrCut{abracadabra}{foo}\csA\csB |\csA\seprouge\csB|\par
\StrCut{abracadabra}{}\csA\csB |\csA\seprouge\csB|+

\subsubsection{\ttfamily\textbackslash StrBetween}
\verb|\StrBetween|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
\smallskip

Les arguments optionnels \argu{nombre1} et \argu{nombre2} valent 1 par dÃ©faut.\par\nobreak\smallskip

Dans \argu{chaine}, renvoie ce qui se trouve entre\footnote{Au sens strict, c'est-Ã&nbsp;-dire \emph{sans} les chaÃ®nes frontiÃ¨re} les occurrences \no\argu{nombre1} de \argu{chaineA} et \no \argu{nombre2} de \argu{chaineB}.\medskip

\begin{Conditions}
	\item Si les occurrences ne sont pas dans l'ordre (\argu{chaineA} \emph{puis} \argu{chaineB}) dans \argu{chaine}, une chaÃ®ne vide est renvoyÃ©e;
	\item Si l'une des 2 occurrences n'existe pas dans \argu{chaine}, une chaÃ®ne vide est renvoyÃ©e;
	\item Si l'un des arguments optionnels \argu{nombre1} ou \argu{nombre2} est nÃ©gatif ou nul, une chaÃ®ne vide est renvoyÃ©e.
\end{Conditions}

\showcode+\StrBetween{xstring}{xs}{ng}\par
|\StrBetween{xstring}{i}{n}|\par
|\StrBetween{xstring}{a}{tring}|\par
|\StrBetween{a bc def }{a}{d}|\par
|\StrBetween{a bc def }{a }{f}|\par
\StrBetween{a1b1a2b2a3b3}{a}{b}\par
\StrBetween[2,3]{a1b1a2b2a3b3}{a}{b}\par
\StrBetween[1,3]{a1b1a2b2a3b3}{a}{b}\par
|\StrBetween[3,1]{a1b1a2b2a3b3}{a}{b}|\par
\StrBetween[3,2]{abracadabra}{a}{bra}+

\subsubsection{\ttfamily\textbackslash StrSubstitute}
\verb|\StrSubstitute|\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
\smallskip

L'argument optionnel \argu{nombre} vaut 0 par dÃ©faut.\par\nobreak\smallskip

Dans \argu{chaine}, la macro remplace les \argu{nombre} premiÃ¨res occurrences de \argu{chaineA} par \argu{chaineB}, sauf si \argu{nombre}${}=0$ auquel cas, \emph{toutes} les occurrences sont remplacÃ©es.

\begin{Conditions}
	\item Si \argu{chaine} est vide, une chaÃ®ne vide est renvoyÃ©e;
	\item Si \argu{chaineA} est vide ou n'existe pas dans \argu{chaine}, la macro est sans effet;
	\item Si \argu{nombre} est supÃ©rieur au nombre d'occurrences de \argu{chaineA}, alors toutes les occurrences sont remplacÃ©es;
	\item Si \argu{nombre}${}&lt;0$ alors la macro se comporte comme si \argu{nombre}${}=0$;
	\item Si \argu{chaineB} est vide, alors les occurrences de \argu{chaineA}, si elles existent, sont supprimÃ©es.
\end{Conditions}

\showcode|\StrSubstitute{xstring}{i}{a}\par
\StrSubstitute{abracadabra}{a}{o}\par
\StrSubstitute{abracadabra}{br}{TeX}\par
\StrSubstitute{LaTeX}{m}{n}\par
\StrSubstitute{a bc def }{ }{M}\par
\StrSubstitute{a bc def }{ab}{AB}\par
\StrSubstitute[1]{a1a2a3}{a}{B}\par
\StrSubstitute[2]{a1a2a3}{a}{B}\par
\StrSubstitute[3]{a1a2a3}{a}{B}\par
\StrSubstitute[4]{a1a2a3}{a}{B}|

\subsubsection{\ttfamily\textbackslash StrDel}
\verb|\StrDel|\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
\smallskip

L'argument optionnel \argu{nombre} vaut 0 par dÃ©faut.\par\nobreak\smallskip

Supprime les \argu{nombre} premiÃ¨res occurrences de \argu{chaineA} dans \argu{chaine}, sauf si \argu{nombre}${}=0$ auquel cas, \emph{toutes} les occurrences sont supprimÃ©es.\medskip

\begin{Conditions}
	\item Si \argu{chaine} est vide, une chaÃ®ne vide est renvoyÃ©e;
	\item Si \argu{chaineA} est vide ou n'existe pas dans \argu{chaine}, la macro est sans effet;
	\item Si \argu{nombre} est supÃ©rieur au nombre d'occurrences de \argu{chaineA}, alors toutes les occurrences sont supprimÃ©es;
	\item Si \argu{nombre}${}&lt;0$ alors la macro se comporte comme si \argu{nombre}${}=0$;
\end{Conditions}

\showcode+\StrDel{abracadabra}{a}\par
\StrDel[1]{abracadabra}{a}\par
\StrDel[4]{abracadabra}{a}\par
\StrDel[9]{abracadabra}{a}\par
\StrDel{a bc def }{ }\par
|\StrDel{a bc def }{def}|+

\subsubsection{\ttfamily\textbackslash StrGobbleLeft}
\verb|\StrGobbleLeft|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip

Dans \argu{chaine}, enlÃ¨ve les \argu{nombre} premieres \USs de gauche.\medskip

\begin{Conditions}
	\item Si \argu{chaine} est vide, renvoie une chaÃ®ne vide;
	\item Si \argu{nombre}${}\leqslant0$, aucune \US n'est supprimÃ©e;
	\item Si \argu{nombre}${}\geqslant{}$\argu{longueurChaine}, toutes les \USs sont supprimÃ©es.
\end{Conditions}

\showcode+\StrGobbleLeft{xstring}{2}\par
|\StrGobbleLeft{xstring}{9}|\par
\StrGobbleLeft{LaTeX}{4}\par
\StrGobbleLeft{LaTeX}{-2}\par
|\StrGobbleLeft{a bc def }{4}|+

\subsubsection{\ttfamily\textbackslash StrLeft}
\verb|\StrLeft|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip

Dans \argu{chaine}, renvoie la sous-chaÃ®ne de gauche de longueur \argu{nombre}.\medskip

\begin{Conditions}
	\item Si \argu{chaine} est vide, renvoie une chaÃ®ne vide;
	\item Si \argu{nombre}${}\leqslant0$, aucune \US n'est retournÃ©e;
	\item Si \argu{nombre}${}\geqslant{}$\argu{longueurChaine}, toutes les \USs sont retournÃ©es.
\end{Conditions}

\showcode+\StrLeft{xstring}{2}\par
\StrLeft{xstring}{9}\par
\StrLeft{LaTeX}{4}\par
|\StrLeft{LaTeX}{-2}|\par
|\StrLeft{a bc def }{5}|+

\subsubsection{\ttfamily\textbackslash StrGobbleRight}
\verb|\StrGobbleRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip

Agit comme \verb|\StrGobbleLeft|, mais enlÃ¨ve les \USs Ã&nbsp; droite de \argu{chaine}.

\showcode+\StrGobbleRight{xstring}{2}\par
|\StrGobbleRight{xstring}{9}|\par
\StrGobbleRight{LaTeX}{4}\par
|\StrGobbleRight{LaTeX}{-2}|\par
|\StrGobbleRight{a bc def }{4}|+

\subsubsection{\ttfamily\textbackslash StrRight}
\verb|\StrRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip

Agit comme \verb|\StrLeft|, mais renvoie les \USs Ã&nbsp; la droite de \argu{chaine}.

\showcode+\StrRight{xstring}{2}\par
\StrRight{xstring}{9}\par
\StrRight{LaTeX}{4}\par
|\StrRight{LaTeX}{-2}|\par
\StrRight{a bc def }{5}+

\subsubsection{\ttfamily\textbackslash StrChar}
\verb|\StrChar|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip

Renvoie l'\US Ã&nbsp; la position \argu{nombre} dans la chaÃ®ne \argu{chaine}.\medskip

\begin{Conditions}
	\item Si \argu{chaine} est vide, aucune \US n'est renvoyÃ©e;
	\item Si \argu{nombre}${}\leqslant0$ ou si \argu{nombre}${}&gt;{}$\argu{longueurChaine}, aucune \US n'est renvoyÃ©e.
\end{Conditions}

\showcode+\StrChar{xstring}{4}\par
|\StrChar{xstring}{9}|\par
|\StrChar{xstring}{-5}|\par
\StrChar{a bc def }{6}+

\subsubsection{\ttfamily\textbackslash StrMid}
\verb|\StrMid|\ARGU{chaine}\ARGU{nombre1}\ARGU{nombre2}\arguC{nom}
\smallskip

Dans \argu{chaine}, renvoie la sous chaÃ®ne se trouvant entre\footnote{Au sens large, c'est-Ã&nbsp;-dire que les chaÃ®nes \guill{frontiÃ¨re} sont renvoyÃ©s.} les positions \argu{nombre1} et \argu{nombre2}.\medskip

\begin{Conditions}
	\item Si \argu{chaine} est vide, une chaÃ®ne vide est renvoyÃ©e;
	\item Si \argu{nombre1}${}&gt;{}$\argu{nombre2}, alors rien n'est renvoyÃ©;
	\item Si \argu{nombre1}${}&lt;1$ et \argu{nombre2}${}&lt;1$ alors rien n'est renvoyÃ©;
	\item Si \argu{nombre1}${}&gt;{}$\argu{longueurChaine} et \argu{nombre2}${}&gt;{}$\argu{longueurChaine}, alors rien n'est renvoyÃ©;
	\item Si \argu{nombre1}${}&lt;1$, alors la macro se comporte comme si \argu{nombre1}${}=1$;
	\item Si \argu{nombre2}${}&gt;{}$\argu{longueurChaine}, alors la macro se comporte comme si \argu{nombre2}${}={}$\argu{longueurChaine}.
\end{Conditions}

\showcode+\StrMid{xstring}{2}{5}\par
\StrMid{xstring}{-4}{2}\par
|\StrMid{xstring}{5}{1}|\par
\StrMid{xstring}{6}{15}\par
\StrMid{xstring}{3}{3}\par
|\StrMid{a bc def }{2}{7}|+

\subsection{Les macros renvoyant des nombres}
\subsubsection{\ttfamily\textbackslash StrLen}
\verb|\StrLen|\ARGU{chaine}\arguC{nom}
\smallskip

Renvoie la longueur de \argu{chaine}.

\showcode+\StrLen{xstring}\par
\StrLen{A}\par
\StrLen{a bc def }+

\subsubsection{\ttfamily\textbackslash StrCount}
\verb|\StrCount|\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
\smallskip

Compte combien de fois \argu{chaineA} est contenue dans \argu{chaine}.\par\medskip

\begin{Conditions}
	\item Si l'un au moins des arguments \argu{chaine} ou \argu{chaineA} est vide, la macro renvoie 0.
\end{Conditions}

\showcode+\StrCount{abracadabra}{a}\par
\StrCount{abracadabra}{bra}\par
\StrCount{abracadabra}{tic}\par
\StrCount{aaaaaa}{aa}+

\subsubsection{\ttfamily\textbackslash StrPosition}
\verb|\StrPosition|\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
\smallskip

L'argument optionnel \argu{nombre} vaut 1 par dÃ©faut.\par\nobreak\smallskip

Dans \argu{chaine}, renvoie la position de l'occurrence \no\argu{nombre} de \argu{chaineA}.\medskip

\begin{Conditions}
	\item Si \argu{nombre} est supÃ©rieur au nombre d'occurrences de \argu{chaineA}, alors la macro renvoie 0.
	\item Si \argu{chaine} ne contient pas \argu{chaineA}, alors la macro renvoie 0.
\end{Conditions}
\medskip

\showcode+\StrPosition{xstring}{ring}\par
\StrPosition[4]{abracadabra}{a}\par
\StrPosition[2]{abracadabra}{bra}\par
\StrPosition[9]{abracadabra}{a}\par
\StrPosition{abracadabra}{z}\par
\StrPosition{a bc def }{d}\par
\StrPosition[3]{aaaaaa}{aa}+

\subsubsection{\ttfamily\textbackslash StrCompare}
\verb|\StrCompare|\etoile\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
\smallskip

Cette macro peut fonctionner avec 2 tolÃ©rances, la tolÃ©rance \guill{normale} qui est sÃ©lectionnÃ©e par dÃ©faut et la tolÃ©rance \guill{stricte}.

\begin{itemize}
	\item La tolÃ©rance normale, activÃ©e par la commande \verb|\comparenormal|.\par
	La macro compare successivement les \US de gauche Ã&nbsp; droite des chaÃ®nes \argu{chaineA} et \argu{chaineB} jusqu'Ã&nbsp; ce qu'une diffÃ©rence apparaisse ou que la fin de la plus courte chaÃ®ne soit atteinte. Si aucune diffÃ©rence n'est trouvÃ©e, la macro renvoie 0. Sinon, la position de la 1\iere{} diffÃ©rence est renvoyÃ©e.
	\item La tolÃ©rance stricte, activÃ©e par la commande \verb|\comparestrict|.\par
	La macro compare les 2 chaÃ®nes. Si elles sont Ã©gales, elle renvoie 0 sinon la position de la 1\iere{} diffÃ©rence est renvoyÃ©e.
\end{itemize}
\medskip

On peut Ã©galement mÃ©moriser le mode de comparaison en cours avec \verb|\savecomparemode|, le modifier par la suite et revenir Ã&nbsp; la situation lors de la sauvegarde avec \verb|\restorecomparemode|.\medskip

Exemples en tolÃ©rance normale :\par\nobreak
\showcode+
\comparenormal
\StrCompare{abcd}{abcd}\par
\StrCompare{abcd}{abc}\par
\StrCompare{abc}{abcd}\par
\StrCompare{a b c}{abc}\par
\StrCompare{aaa}{baaa}\par
\StrCompare{abc}{xyz}\par
\StrCompare{123456}{123457}\par
\StrCompare{abc}{}+

Exemples en tolÃ©rance stricte :\par\nobreak
\showcode+\comparestrict
\StrCompare{abcd}{abcd}\par
\StrCompare{abcd}{abc}\par
\StrCompare{abc}{abcd}\par
\StrCompare{a b c}{abc}\par
\StrCompare{aaa}{baaa}\par
\StrCompare{abc}{xyz}\par
\StrCompare{123456}{123457}\par
\StrCompare{abc}{}+

\section{Modes de fonctionnement}
\subsection{DÃ©veloppement des arguments}
\label{devarg}
\subsubsection{Les macros {\ttfamily \textbackslash fullexpandarg}, {\ttfamily \textbackslash expandarg} et {\ttfamily \textbackslash noexpandarg}}
La macro \verb|\fullexpandarg| est appelÃ©e par dÃ©faut, ce qui fait que certains arguments (en \textcolor{violet}{violet} dans la liste ci dessous) transmis aux macros sont dÃ©veloppÃ©s le plus possible (pour cela, un \verb|\edef| est utilisÃ©). Ce mode de dÃ©veloppement maximal permet dans la plupart des cas d'Ã©viter d'utiliser des chaÃ®nes d'\verb|\expandafter|. Le code en est souvent allÃ©gÃ©.

On peut interdire le dÃ©veloppement de ces arguments (et ainsi revenir au comportement normal de \TeX) en invoquant \verb|\noexpandarg| ou \verb|\normalexpandarg| qui sont synonymes.\medskip

Il existe enfin un autre mode de dÃ©veloppement de ces arguments que l'on appelle avec \verb|\expandarg|. Dans ce cas, le \textbf{premier token} de ces arguments est dÃ©veloppÃ© \emph{une fois} avant que la macro ne soit appelÃ©e. Si l'argument contient plus d'un token, les tokens qui suivent le premier ne sont pas dÃ©veloppÃ©s (on peut contourner cette volontaire limitation et utiliser la macro \verb|\StrExpand|, voir page~\pageref{scancs}).\medskip

Les commandes \verb|\fullexpandarg|, \verb|\noexpandarg|, \verb|\normalexpandarg| et \verb|\expandarg| peuvent Ãªtre appelÃ©es Ã&nbsp; tout moment dans le code et fonctionnent comme des bascules. On peut rendre leur portÃ©e locale dans un groupe.\medskip

On peut Ã©galement mÃ©moriser le mode de dÃ©veloppement en cours avec \verb|\saveexpandmode|, le modifier par la suite et revenir Ã&nbsp; la situation lors de la sauvegarde avec \verb|\restoreexpandmode|.\medskip

Dans la liste ci-dessous, on peut voir en \textcolor{violet}{violet} quels arguments sont soumis Ã&nbsp; l'Ã©ventuel dÃ©veloppement pour chaque macro vue dans le chapitre prÃ©cedent :\smallskip

\parindent3em
\begin{itemize}
	\item\verb|\IfSubStr|\etoile{\colorise\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfSubStrBefore|\etoile{\colorise\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfSubStrBehind|\etoile{\colorise\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfBeginWith|\etoile{\colorise\ARGU{chaine}\ARGU{chaineA}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfEndWith|\etoile{\colorise\ARGU{chaine}\ARGU{chaineA}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfInteger|{\colorise\ARGU{nombre}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfDecimal|{\colorise\ARGU{nombre}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfStrEq|\etoile{\colorise\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfEq|\etoile{\colorise\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfStrEqCase|\etoile{\colorise\ARGU{chaine}\texttt{\color{black}\{}\colorise\ARGU{chaine1}}\ARGU{code1}\par
		\setbox0=\hbox{{\ttfamily\string\IfStrEqCase}\etoile\ARGU{chaine}{\ttfamily\{}}
		\hskip\wd0{\colorise\ARGU{chaine2}}\ARGU{code2}\par
		\hskip\wd0\ \ldots\par
		\hskip\wd0{\colorise\ARGU{chaine $n$}}\ARGU{code $n$}\verb|}|\arguC{code alternatif}
	\item\verb|\IfEqCase|\etoile{\colorise\ARGU{chaine}\texttt{\color{black}\{}\colorise\ARGU{chaine1}}\ARGU{code1}\par
		\setbox0=\hbox{{\ttfamily\string\IfEqCase}\etoile\ARGU{chaine}{\ttfamily\{}}
		\hskip\wd0{\colorise\ARGU{chaine2}}\ARGU{code2}\par
		\hskip\wd0\ \ldots\par
		\hskip\wd0{\colorise\ARGU{chaine $n$}}\ARGU{code $n$}\verb|}|\arguC{code alternatif}
	\item\verb|\StrBefore|\etoile{\colorise\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}}\arguC{nom}
	\item\verb|\StrBehind|\etoile{\colorise\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}}\arguC{nom}
	\item\verb|\StrBetween|\etoile{\colorise\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}}\arguC{nom}
	\item\verb|\StrSubstitute|{\colorise\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}}\arguC{nom}
	\item\verb|\StrDel|{\colorise\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}}\arguC{nom}
	\item\verb|\StrSplit|{\colorise\ARGU{chaine}\ARGU{nombre}}\ARGU{chaineA}\ARGU{chaineB}\qquad{\small(voir page~\pageref{StrSplit} pour la macro \verb|StrSplit|)}
	\item\verb|\StrGobbleLeft|{\colorise\ARGU{chaine}\ARGU{nombre}}\arguC{nom}
	\item\verb|\StrLeft|{\colorise\ARGU{chaine}\ARGU{nombre}}\arguC{nom}
	\item\verb|\StrGobbleRight|{\colorise\ARGU{chaine}\ARGU{nombre}}\arguC{nom}
	\item\verb|\StrRight|{\colorise\ARGU{chaine}\ARGU{nombre}}\arguC{nom}
	\item\verb|\StrChar|{\colorise\ARGU{chaine}\ARGU{nombre}}\arguC{nom}
	\item\verb|\StrMid|{\colorise\ARGU{chaine}\ARGU{nombre1}\ARGU{nombre2}}\arguC{nom}
	\item\verb|\StrLen|{\colorise\ARGU{chaine}}\arguC{nom}
	\item\verb|\StrCount|{\colorise\ARGU{chaine}\ARGU{chaineA}}\arguC{nom}
	\item\verb|\StrPosition|{\colorise\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}}\arguC{nom}
	\item\verb|\StrCompare|{\colorise\ARGU{chaineA}\ARGU{chaineB}}\arguC{nom}
\end{itemize}
\parindent0pt

\subsubsection{CaractÃ¨res et lexÃ¨mes autorisÃ©s dans les arguments}
Tout d'abord, quelque soit le mode de dÃ©veloppement choisi, \textbf{les tokens de catcode 6 et 14 (habituellement {\ttfamily\#} et {\ttfamily\%}) sont interdits dans tous les arguments}\footnote{Le token {\ttfamily\#} sera peut-Ãªtre autorisÃ© dans une future version !}.\bigskip

Lorsque le mode \verb|\fullexpandarg| est activÃ©, les arguments sont Ã©valuÃ©s Ã&nbsp; l'aide de la primitive \verb|\edef| avant d'Ãªtre transmis aux macros. Par consÃ©quent, sont autorisÃ©s dans les arguments :
\parindent3em
\begin{itemize}
	\item les lettres, majuscules, minuscules, accentuÃ©es\footnote{Pour pouvoir utiliser des lettres accentuÃ©es de faÃ§on fiable, il est nÃ©cessaire de charger le packages \texttt{\string\fontenc} avec l'option \texttt{[T1]}, ainsi que \texttt{\string\inputenc} avec l'option correspondant au codage du fichier tex.} ou non, les chiffres, les espaces\footnote{Selon la rÃ¨gle \TeX{}iÃ¨nne, plusieurs espaces consÃ©cutifs n'en font qu'un.} ainsi que tout autre token de catcode 10, 11 ou 12 (signes de ponctuation, signes opÃ©ratoires mathÃ©matiques, parenthÃ¨ses, crochets, etc);
	\item les tokens de catcode 1 Ã&nbsp; 4, qui sont habituellement : \og\verb|{|\fg\quad\og\verb|}|\fg\footnote{Attention : les accolades \textbf{doivent} Ãªtre Ã©quilibrÃ©es dans les arguments !}\quad\og\verb|$|\fg\quad\og\verb|&amp;|\fg
	\item les tokens de catcode 7 et 8, qui sont habituellement : \og\verb|^|\fg\quad\og\verb|_|\fg
	\item toute sÃ©quence de contrÃ´le si elle est purement dÃ©veloppable\footnote{C'est-Ã&nbsp;-dire qu'elle peut Ãªtre mise Ã&nbsp; l'intÃ©rieur d'un {\ttfamily\string\edef }.} et dont le dÃ©veloppement maximal donne des caractÃ¨res autorisÃ©s.
\end{itemize}
\parindent0pt\smallskip

Lorsque les arguments ne sont plus dÃ©veloppÃ©s (utilisation de \verb|\noexpandarg|), on peut aussi inclure dans les arguments n'importe quel token, quelque soit le code qui en rÃ©sulte comme par exemple toute sÃ©quence de contrÃ´le, mÃªme non dÃ©finie ou tout token de catcode 13. On peut Ã©galement inclure dans les arguments des tokens de test comme \verb|\if| ou \verb|\ifx| ou tout autre token de test, mÃªme sans leur \verb|\fi| correspondant; ou bien un \verb|\csname| sans le \verb|\endcsname| correspondant.

Dans l'exemple suivant, l'argument contient un \verb|\ifx| \emph{sans} le \verb|\fi|, et l'on isole ce qui est entre le \verb|\ifx| et le \verb|\else| :\par\medskip\nobreak

\showcode+\noexpandarg
\StrBetween{\ifx ab faux \else vrai}{\ifx}{\else}+
\medskip

Lorsqu'on utilise \verb|\expandarg|, la prÃ©caution concerne le premier token qui est dÃ©veloppÃ© une fois et doit donc Ãªtre dÃ©fini. Les autres tokens sont laissÃ©s tel quels comme avec \verb|\noexpandarg|.

\subsection{DÃ©veloppement des macros, argument optionnel}
\label{argumentoptionnel}
Les macros de ce package ne sont pas purement dÃ©veloppables et ne peuvent donc pas Ãªtre mises dans l'argument d'un \verb|\edef|. L'imbrication des macros de ce package n'est pas permise non plus.\medskip

C'est pour cela que les macros renvoyant un rÃ©sultat, c'est-Ã&nbsp;-dire toutes sauf les tests, sont dotÃ©es d'un argument optionnel venant en derniÃ¨re position. Cet argument prend la forme de \arguC{nom}, oÃ¹ \argu{nom} est une sÃ©quence de contrÃ´le qui recevra (l'assignation se fait avec un \verb|\edef|) le rÃ©sultat de la macro, ce qui fait que \argu{nom} est purement dÃ©veloppable et peut donc se trouver dans l'argument d'un \verb|\edef|. Dans le cas de la prÃ©sence d'un argument optionnel en derniÃ¨re position, aucun affichage n'aura lieu. Cela permet donc contourner les limitations Ã©voquÃ©es dans les exemples ci dessus.\medskip

Ainsi cette construction non permise censÃ©e assigner Ã&nbsp; \verb|\Resultat| les 4 caractÃ¨res de gauche de \verb|xstring| :\par\nobreak
\hspace{0.2\linewidth}\verb|\edef\Resultat{\StrLeft{xstring}{4}}|\par\nobreak
\qquad est Ã©quivalente Ã&nbsp; :\par\nobreak
\hspace{0.2\linewidth}\verb|\StrLeft{xstring}{4}[\Resultat]|\medskip

Et cette imbrication non permise censÃ©e enlever le premier et le dernier caractÃ¨re de \verb|xstring| :\par\nobreak
\hspace{0.2\linewidth}\verb|\StrGobbleLeft{\StrGobbleRight{xstring}{1}}{1}|\par\nobreak
\qquad se programme ainsi :\par\nobreak
\hspace{0.2\linewidth}\verb|\StrGobbleRight{xstring}{1}[\machaine]|\par\nobreak
\hspace{0.2\linewidth}\verb|\StrGobbleLeft{\machaine}{1}|\par

\subsection{Traitement des arguments}
\label{developpementarguments}
\subsubsection{Traitement Ã&nbsp; l'\US prÃ©s}
Les macros de \Xstring traitent les arguments \US par \US. Dans le code \TeX{}, une \US\footnote{Pour les utilisateurs familiers avec la programmation \LaTeX, une \US est ce qui est supprimÃ© par la macro \texttt{\string\@gobble} dont le code, d'une grande simplicitÃ©, est : {\ttfamily\string\def\string\@gobble\string#1\string{\string}}} est soit :\par\nobreak\smallskip\parindent3em
\begin{itemize}
	\item une sÃ©quence de contrÃ´le;
	\item un groupe, c'est Ã&nbsp; dire une suite de tokens situÃ©e entre deux accolades Ã©quilibrÃ©es;
	\item un caractÃ¨re ne faisant pas partie des 2 espÃ¨ces ci dessus.
\end{itemize}
\medskip\parindent0pt

Voyons ce qu'est la notion d'\US sur un exemple. Prenons cet argument : \og\verb|ab\textbf{xyz}cd|\fg

\nobreak Il contient 6 \USs qui sont : \og\verb|a|\fg, \og\verb|b|\fg, \og\verb|\textbf|\fg, \og\verb|{xyz}|\fg, \og\verb|c|\fg{} et \og\verb|d|\fg.

\nobreak\medskip Que va t-il arriver si l'on se place sous \verb|\noexpandarg| et que l'on demande Ã&nbsp; \Xstring de trouver la longueur de cet argument et d'en trouver le 4\ieme{} \guill{caractÃ¨re} ?\medskip

\showcode+\noexpandarg
\StrLen{ab\textbf{xyz}cd}\par
\StrChar{ab\textbf{xyz}cd}{4}[\mychar]
\meaning\mychar+
\fullexpandarg
\medskip

Il est nÃ©cessaire d'utiliser \verb|\meaning| pour bien visualiser le vÃ©ritable contenu de \verb|\mychar| et non pas de simplement d'appeler cette sÃ©quence de contrÃ´le, ce qui fait perdre des informations ---~les accolades ici. On voit qu'on n'obtient pas vraiment un \guill{caractÃ¨re}, mais cela Ã©tait prÃ©visible : il s'agit d'une \US.

\subsubsection{Exploration des groupes}
Par dÃ©faut, la commande \verb|\noexploregroups| est appelÃ©e et donc dans l'argument Ã&nbsp; examiner qui contient la chaÃ®ne de tokens, \Xstring considÃ¨re les groupes entre accolades comme \USs fermÃ©es dans lesquelles \Xstring ne regarde pas.

Pour certains besoins spÃ©cifiques, il peut Ãªtre nÃ©cessaire de modifier le mode de lecture des arguments et d'explorer l'intÃ©rieur des groupes entre accolades. Pour cela on peut invoquer \verb|\exploregroups|.\medskip

Que va donner ce nouveau mode d'exploration sur l'exemple prÃ©cÃ©dent ? \Xstring ne va plus compter le groupe comme une seule \US mais va compter les \USs se trouvant Ã&nbsp; l'intÃ©rieur, et ainsi de suite s'il y avait plusieurs niveaux d'imbrication de groupes:

\nobreak\smallskip
\showcode+\noexpandarg
\exploregroups
\StrLen{ab\textbf{xyz}cd}\par
\StrChar{ab\textbf{xyz}cd}{4}[\mychar]
\meaning\mychar+
\fullexpandarg\noexploregroups
\medskip

L'exploration des groupes peut se rÃ©veler utile pour le comptage, le calcul de position ou les tests, mais comporte une limitation lorsque l'on appelle des macros renvoyant des chaÃ®nes : lorsqu'un argument est coupÃ© Ã&nbsp; l'intÃ©rieur d'un groupe, alors \textbf{le rÃ©sultat ne tient pas compte de ce qui se trouve Ã&nbsp; l'extÃ©rieur de ce groupe}. Il faut donc utiliser ce mode en connaissance de cause lorsque l'on utilise les macros renvoyant des chaÃ®nes.

Voyons ce que cela signifie sur un exemple : mettons que l'on veuille renvoyer ce qui se trouve Ã&nbsp; droite de la 2\ieme{} occurrence de \verb|\a| dans l'argument \verb|\a1{\b1\a2}\a3|. Comme l'on explore les groupes, cette occurrence se trouve Ã&nbsp; l'intÃ©rieur du groupe \verb|{\b1\a2}|. Le rÃ©sultat renvoyÃ© sera donc : \verb|\b1|. VÃ©rifions-le :

\showcode+\noexpandarg
\exploregroups
\StrBefore[2]{\a1{\b1\a2}\a3}{\a}[\mycs]
\meaning\mycs+

L'exploration des groupes\footnote{On peut consulter le fichier de test de \Xstring qui comporte de nombreux exemples et met en Ã©vidence les diffÃ©rences selon le mode d'exploration des groupes.} peut ainsi changer le comportement de la plupart des macros de \Xstring, Ã&nbsp; l'exception de \verb|\IfInteger|, \verb|\IfDecimal|, \verb|\IfStrEq|, \verb|\IfEq| et \verb|\StrCompare| qui sont insensibles au mode d'exploration en cours.

De plus, pour des raison d'Ã©quilibrage d'accolades, 2 macros n'opÃ¨rent qu'en mode \verb|\noexploregroups|, quelque soit le mode d'exploration en cours : \verb|\StrBetween| et \verb|\StrMid|.\medskip

On peut mÃ©moriser le mode de d'exploration en cours avec \verb|\saveexploremode|, le modifier par la suite et revenir Ã&nbsp; la situation lors de la sauvegarde avec \verb|\restoreexploremode|.

\subsection{Catcodes et macros Ã©toilÃ©es}
\label{macrosetoilees}
Les macros de \Xstring tiennent compte des catcodes des tokens constituant les arguments. Il faut donc garder Ã&nbsp; l'esprit, particuliÃ¨rement lors des tests, que les tokens \emph{et leurs catcodes} sont examinÃ©s.\medskip

Par exemple, ces 2 arguments :\par\nobreak\smallskip
\hfil\verb|{\string a\string b}|\qquad et\qquad\verb|{ab}|\hfil{}\par\smallskip
ne se dÃ©veloppent pas en 2 arguments Ã©gaux aux yeux de \Xstring. Dans le premier cas, Ã&nbsp; cause de l'emploi de la primitive \verb|\string|, les caractÃ¨res \og\verb|ab|\fg{} ont un catcode de 12 alors que dans l'autre cas, ils ont leurs catcodes naturels de 11. Il convient donc d'Ãªtre conscient de ces subtilitÃ©s lorsque l'on emploie des primitives dont les rÃ©sultats sont des chaÃ®nes de caractÃ¨res ayant des catcodes de 12 et 10. Ces primitives sont par exemple : \verb|\string|, \verb|\detokenize|, \verb|\meaning|, \verb|\jobname|, \verb|\fontname|, \verb|\romannumeral|, etc.\medskip

Pour demander aux macros de ne pas tenir compte des catcodes, on peut utiliser les macros Ã©toilÃ©es. AprÃ¨s l'Ã©ventuel dÃ©veloppement des arguments en accord avec le mode de dÃ©veloppement, celles-ci convertissent (Ã&nbsp; l'aide d'un \verb|\detokenize|) leur arguments en chaÃ®nes de caractÃ¨res dont les catcodes sont 12 et 10 pour l'espace, avant que la macro non Ã©toilÃ©e travaille sur ces arguments ainsi modifiÃ©s. Il faut noter que les arguments optionnels ne sont pas concernÃ©s par ces modifications et gardent leur catcode.\smallskip

Voici un exemple :\par\nobreak\smallskip
\showcode+\IfStrEq{\string a\string b}{ab}{vrai}{faux}\par
\IfStrEq*{\string a\string b}{ab}{vrai}{faux}+
\smallskip

Les chaÃ®nes n'Ã©tant pas Ã©gales Ã&nbsp; cause des catcodes, le test est bien \emph{nÃ©gatif} dans la version non Ã©toilÃ©e.\bigskip

\textbf{Attention} : utiliser une macro Ã©toilÃ©e a des consÃ©quenses ! Les arguments sont \guill{dÃ©tokÃ©nisÃ©s}, il n'y a donc plus de sÃ©quence de contrÃ´le, plus de goupes, ni aucun caractÃ¨re de catcode spÃ©cial puisque tout est converti en caractÃ¨res \guill{inoffensifs} ayant le mÃªme catcode.\medskip

Ainsi, pour les macros renvoyant une chaÃ®ne, si on emploie les versions Ã©toilÃ©es, le rÃ©sultat sera une chaÃ®ne de caractÃ¨res dont les catcodes sont 12, et 10 pour l'espace. Et donc, aprÃ¨s un \og\verb|\StrBefore*{a \b c d}{c}[\montexte]|\fg{}, la sÃ©quence de contrÃ´le \verb|\montexte| se dÃ©veloppera en \og{}\verb|a|${}_{12}$\verb*| |${}_{10}$\verb|\|${}_{12}$\verb|b|${}_{12}$\verb*| |${}_{10}$\fg{}.\medskip

Les macros dÃ©tokenisant leur arguments par l'utilisation de l'Ã©toile sont prÃ©sentÃ©es dans la liste ci-dessous. Pour chacune d'entre elles, on peut voir en \textcolor{violet}{violet} quels arguments seront dÃ©tokenisÃ© lorsque l'Ã©toile sera employÃ©e :

\nobreak\smallskip\parindent3em
\begin{itemize}
	\item\verb|\IfSubStr|\etoile\arguC{nombre}{\colorise\ARGU{chaine}\ARGU{chaineA}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfSubStrBefore|\etoile\arguCC{nombre1}{nombre2}{\colorise\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfSubStrBehind|\etoile\arguCC{nombre1}{nombre2}{\colorise\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfBeginWith|\etoile{\colorise\ARGU{chaine}\ARGU{chaineA}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfEndWith|\etoile{\colorise\ARGU{chaine}\ARGU{chaineA}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfStrEq|\etoile{\colorise\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfEq|\etoile{\colorise\ARGU{chaineA}\ARGU{chaineB}}\ARGU{vrai}\ARGU{faux}
	\item\verb|\IfStrEqCase|\etoile{\colorise\ARGU{chaine}\texttt{\color{black}\{}\colorise\ARGU{chaine1}}\ARGU{code1}\par
		\setbox0=\hbox{{\ttfamily\string\IfStrEqCase}\etoile\ARGU{chaine}{\ttfamily\{}}
		\hskip\wd0{\colorise\ARGU{chaine2}}\ARGU{code2}\par
		\hskip\wd0\ \ldots\par
		\hskip\wd0{\colorise\ARGU{chaine $n$}}\ARGU{code $n$}\verb|}|\arguC{code alternatif}
	\item\verb|\IfEqCase|\etoile{\colorise\ARGU{chaine}\texttt{\color{black}\{}\colorise\ARGU{chaine1}}\ARGU{code1}\par
		\setbox0=\hbox{{\ttfamily\string\IfEqCase}\etoile\ARGU{chaine}{\ttfamily\{}}
		\hskip\wd0{\colorise\ARGU{chaine2}}\ARGU{code2}\par
		\hskip\wd0\ \ldots\par
		\hskip\wd0{\colorise\ARGU{chaine $n$}}\ARGU{code $n$}\verb|}|\arguC{code alternatif}
	\item\verb|\StrBefore|\etoile\arguC{nombre}{\colorise\ARGU{chaine}\ARGU{chaineA}}\arguC{nom}
	\item\verb|\StrBehind|\etoile\arguC{nombre}{\colorise\ARGU{chaine}\ARGU{chaineA}}\arguC{nom}
	\item\verb|\StrBetween|\etoile\arguCC{nombre1}{nombre2}{\colorise\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}}\arguC{nom}
	\item\verb|\StrCompare|\etoile{\colorise\ARGU{chaineA}\ARGU{chaineB}}\arguC{nom}
\end{itemize}
\parindent0pt

\section{Macros avancÃ©es pour la programmation}
Bien que \Xstring ait la possibilitÃ© de lire et traiter des arguments contenant du code \TeX{} ou \LaTeX{} ce qui devrait couvrir la plupart des besoins en programmation, il peut arriver pour des besoins trÃ¨s spÃ©cifiques que les macros dÃ©critesz prÃ©cÃ©demment ne suffisent pas. Ce chapitre prÃ©sente d'autres macros qui permettent d'aller plus loin ou de contourner certaines limitations.
\subsection{Recherche d'un groupe, les macros {\ttfamily\textbackslash StrFindGroup} et {\ttfamily\textbackslash groupID}}
Lorsque le mode \verb=\exploregroups= est actif, la macro \verb=\StrFindGroup= permet de trouver un groupe entre accolades explicites en spÃ©cifiant son identifiant :

\nobreak\smallskip
\verb|\StrFindGroup|\ARGU{argument}\ARGU{identifiant}\arguC{nom}\medskip

Lorsque le groupe caractÃ©risÃ© par l'identifiant n'existe pas, une chaÃ®ne vide sera assignÃ©e Ã&nbsp; la sÃ©quence de contrÃ´le \argu{nom}. Si le groupe existe, ce groupe \emph{avec ses accolades} sera assignÃ© Ã&nbsp; \argu{nom}.\smallskip

Cet identifiant est une suite d'entiers sÃ©parÃ©s par des virgules caractÃ©risant le groupe cherchÃ© dans l'argument. Le premier entier est le $n$\ieme{} groupe (d'imbrication 1) dans lequel est le groupe cherchÃ©. Puis, en se plaÃ§ant dans ce groupe, le 2\ieme{} entier est le $n$\ieme{} groupe dans lequel est le groupe cherchÃ©. Et ainsi de suite jusqu'Ã&nbsp; ce que l'imbrication du groupe soit atteinte.\bigskip

Prenons par exemple l'argument suivant oÃ¹ l'on a 3 niveaux d'imbrication de groupes. Pour plus de clartÃ©, les accolades dÃ©limitant les groupes sont colorÃ©es en rouge pour l'imbrication de niveau 1, en bleu pour le niveau 2 et en vert pour le niveau 3. Les groupes dans chaque imbrication sont ensuite numÃ©rotÃ©s selon la rÃ¨gle dÃ©crite ci-dessus :
\begingroup
	\def\AccO#1{\text{\color{#1}\ttfamily\{}}
	\def\AccF#1{\text{\color{#1}\ttfamily\}}}
	\def\texte#1{\text{\texttt{\color{black}#1}}}
	\def\decalbrace{\vphantom{\underbrace{A}_A}}
	\[\texte{a}{\color{red}\underbrace{\AccO{red}{\color{blue}\underbrace{\decalbrace\AccO{blue}\texte{bc}\AccF{blue}}_{\color{blue}1}}\texte{d}{\color{blue}\underbrace{\decalbrace\AccO{blue}\texte{efg}\AccF{blue}}_{\color{blue}2}}\AccF{red}}_{\color{red}1}}\texte{h}{\color{red}\underbrace{\AccO{red}{\color{blue}\underbrace{\decalbrace\AccO{blue}\texte{ij}\AccF{blue}}_{\color{blue}1}}{\color{blue}\underbrace{\decalbrace\AccO{blue}\texte{k}\AccF{blue}}_{\color{blue}2}}{\color{blue}\underbrace{\AccO{blue}\texte{l}{\color{green}\underbrace{\AccO{green}\texte{m}\AccF{green}}_{\color{green}1}}{\color{green}\underbrace{\AccO{green}\texte{no}\AccF{green}}_{\color{green}2}}\AccF{blue}}_{\color{blue}3}}\texte{p}\AccF{red}}_{\color{red}2}}\]
\endgroup
\smallskip
Dans cet exemple :

\nobreak\parindent3em
\begin{itemize}
	\item le groupe \verb={{bc}d{efg}}= a donc pour identifiant \texttt{\color{red}1};
	\item le groupe \verb={ij}= a pour identifiant \texttt{{\color{red}2},\color{blue}1};
	\item le groupe \verb={no}= a pour identifiant \texttt{{\color{red}2},{\color{blue}3},\color{green}2};
	\item l'argument dans sa totalitÃ© \og\verb=a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}=\fg{} a pour identifiant \verb=0=, seul cas oÃ¹ l'entier 0 est contenu dans l'identifiant d'un groupe.
\end{itemize}
\parindent0pt
\medskip
Voici l'exemple complet :\par\nobreak\smallskip
\showcode+\exploregroups
\expandarg
\def\chaine{a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}}
\StrFindGroup{\chaine}{1}[\mongroupe]
\meaning\mongroupe\par
\StrFindGroup{\chaine}{2,1}[\mongroupe]
\meaning\mongroupe\par
\StrFindGroup{\chaine}{2,3,2}[\mongroupe]
\meaning\mongroupe\par
\StrFindGroup{\chaine}{2,5}[\mongroupe]
\meaning\mongroupe+
\bigskip

Le processus inverse existe, et plusieurs macros de \Xstring donnent aussi comme information l'identifiant du groupe dans lequel elles ont fait une coupure ou trouvÃ© une recherche. Ces macros sont :  \verb|\IfSubStr|, \verb|\StrBefore|, \verb|\StrBehind|, \verb|\StrSplit|, \verb|\StrLeft|, \verb|\StrGobbleLeft|, \verb|\StrRight|, \verb|\StrGobbleRight|, \verb|\StrChar|, \verb|\StrPosition|.\medskip

AprÃ¨s l'appel Ã&nbsp; ces macros, la commande \verb|\groupID| se dÃ©veloppe en l'identifiant du groupe dans lequel la coupure s'est faite ou la recherche d'un argument a abouti. Lorsque la coupure ne peut avoir lieu ou que la recherche n'a pas abouti, \verb|\groupID| est vide. Ã‰videmment, l'utilisation de \verb|\groupID| n'a de sens que lorsque le mode \verb|\exploregroups| est actif, et quand les macros ne sont pas Ã©toilÃ©es.\smallskip

Voici quelques exemples avec la macro \verb|\StrChar| :\par\nobreak\smallskip
\showcode+\exploregroups
char 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
\string\groupID = \groupID\par
char 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
\string\groupID = \groupID\par
char 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
\string\groupID = \groupID\par
char 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
\string\groupID = \groupID+

\subsection{Coupure d'une chaÃ®ne, la macro {\ttfamily\textbackslash StrSplit}}
\label{StrSplit}
Voici la syntaxe de cette macro :\par\nobreak\smallskip

\verb|\StrSplit|\ARGU{chaine}\ARGU{nombre}\ARGU{chaineA}\ARGU{chaineB}
\smallskip

La \argu{chaine}, est coupÃ©e en deux chaÃ®nes juste aprÃ¨s l'\US se situant Ã&nbsp; la position \argu{nombre}. La partie gauche est assignÃ© Ã&nbsp; la sÃ©quence de contrÃ´le \argu{chaineA} et la partie droite Ã&nbsp; \argu{chaineB}.\par
Cette macro renvoie \emph{deux chaÃ®nes} et donc \textbf{n'affiche rien}. Par consÃ©quent, elle ne dispose pas de l'argument optionnel en derniÃ¨re position.\medskip

\begin{Conditions}
	\item Si \argu{nombre}${}\leqslant0$, \argu{chaineA} sera vide et \argu{chaineB} contiendra la totalitÃ© de \argu{chaine};
	\item Si \argu{nombre}${}\geqslant$\argu{longueurChaine}, \argu{chaineA} contiendra la totalitÃ© de \argu{chaine} et \argu{chaineB} sera vide;
	\item Si \argu{chaine} est vide \argu{chaineA} et \argu{chaineB} seront vides, quelque soit l'entier \argu{nombre}.
\end{Conditions}

\showcode+\def\seprouge{{\color{red}|}}
\StrSplit{abcdef}{4}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{a b c }{2}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{abcdef}{1}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{abcdef}{5}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{abcdef}{9}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{abcdef}{-3}{\csA}{\csB}|\csA\seprouge\csB|+

Lorsque l'exploration des groupes est activÃ©e, et que l'on demande une coupure en fin de groupe, alors une chaÃ®ne contiendra la totalitÃ© du groupe tandis que l'autre sera vide comme on le voit sur cet exemple :\par\nobreak\smallskip
\showcode+\exploregroups
\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
\meaning\strB+\medskip

Une version Ã©toilÃ©e de cette macro existe : dans ce cas, la coupure se fait juste avant la prochaine \US qui suit l'\US dÃ©sirÃ©e. La version Ã©toilÃ©e ne donne des rÃ©sultats diffÃ©rents de la version normale que lorsque la $n$\ieme{} \US est Ã&nbsp; la fin d'un groupe auquel cas, la coupure intervient non pas aprÃ¨s cette \US mais \emph{avant} la prochaine \US, que \verb|\StrSplit| atteint en fermant autant de groupes que nÃ©cessaire.\smallskip

\showcode+\exploregroups
Utilisation sans Ã©toile :\par
\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
\meaning\strB\par
\string\groupID\ = \groupID\par\medskip
Utilisation avec \'etoile :\par
\StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
\meaning\strB\par
\string\groupID\ = \groupID+

\subsection{Assigner un contenu verb, la macro \ttfamily\textbackslash verbtocs}
\label{verbtocs}
La macro \verb|\verbtocs| permet le lire le contenu d'un \guill{verb} qui peut contenir tous les caractÃ¨res spÃ©ciaux : \verb|&amp;|, \verb|~|, \verb|\|, \verb|{|, \verb|}|, \verb|_|, \verb|#|, \verb|$|, \verb|^| et \verb|%|. Les caractÃ¨res \guill{normaux} gardent leur catcodes naturels, sauf les caractÃ¨res spÃ©ciaux qui prennent un catcode de 12. Ensuite, ces caractÃ¨res sont assignÃ©s Ã&nbsp; une sÃ©quence de contrÃ´le. La syntaxe complÃ¨te est :\par\nobreak\medskip
\hfill\verb|\verbtocs|\ARGU{nom}|\argu{caractÃ¨res}|\hfill{}
\smallskip

\argu{nom} est le nom d'une sÃ©quence de contrÃ´le qui recevra Ã&nbsp; l'aide d'un \verb|\edef| les \argu{caractÃ¨res}. \argu{nom} contiendra donc des caractÃ¨res de catcodes 12 ou 10 pour l'espace.\medskip

Par dÃ©faut, le token dÃ©limitant le contenu verb est \guill{|}, Ã©tant entendu que ce token ne peut Ãªtre Ã&nbsp; la fois le dÃ©limiteur et Ãªtre contenu dans ce qu'il dÃ©limite. Au cas oÃ¹ on voudrait lire un contenu verb contenant \guill{|}, on peut changer Ã&nbsp; tout moment le token dÃ©limitant le contenu verb par la macro :\par\medskip
\hfill\verb|\setverbdelim|\ARGU{token}\hfill{}\smallskip

Tout \argu{token} de catcode 12 peut Ãªtre utilisÃ©\footnote{Plusieurs tokens peuvent Ãªtre utilisÃ©s au risque d'alourdir la syntaxe de \texttt{\string\verbtocs} ! Pour cette raison, avertissement sera Ã©mis si l'argument de \texttt{\string\setverbdelim} contient plusieurs tokens.}.\medskip

Concernant ces arguments verb, il faut tenir compte des deux points suivants :
\begin{itemize}
	\item tous les caractÃ¨res se trouvant avant |\argu{caractÃ¨res}| seront ignorÃ©s;
	\item Ã&nbsp; l'intÃ©rieur des dÃ©limiteurs, tous les espaces sont comptabilisÃ©s mÃªme s'ils sont consÃ©cutifs.
\end{itemize}
\medskip

Exemple :\par\nobreak\medskip
\showcode+\verbtocs{\resultat}  |a   &amp; b{ c% d$ e \f|
J'affiche le rÃ©sultat :\par\resultat+

\subsection{Tokenisation d'un texte vers une sÃ©quence de contrÃ´le, la macro \ttfamily\textbackslash tokenize}
Le processus inverse de ce qui a Ã©tÃ© vu au dessus consiste Ã&nbsp; interprÃ©ter une suite de caractÃ¨res en tokens. Pour cela, on dispose de la macro :\par\nobreak\medskip
\hfill\verb|\tokenize|\ARGU{nom}\ARGU{texte}\hfill{}
\smallskip

\argu{texte} est dÃ©veloppÃ© le plus possible si l'on a invoquÃ© \verb|\fullexpandarg|; il n'est pas dÃ©veloppÃ© si l'on a invoquÃ© une des commandes \verb|\noexpandarg| ou \verb|\expandarg|. AprÃ¨s dÃ©veloppement Ã©ventuel, le \argu{texte} est transformÃ© en tokens puis assignÃ© Ã&nbsp; l'aide d'un \verb|\def| Ã&nbsp; la sÃ©quence de contrÃ´le \argu{nom}.\medskip

Voici un exemple oÃ¹ l'on dÃ©tokenise un argument, on affiche le texte obtenu, puis on transforme ce texte en ce que l'argument Ã©tait au dÃ©but; enfin, on affiche le rÃ©sultat de la tokenisation :\par\nobreak\medskip
\showcode+\verbtocs{\text}|\textbf{a} $\frac{1}{2}$|
texte : \text
\tokenize{\resultat}{\text}\par
rÃ©esultat : \resultat+
\medskip

Il est bien Ã©vident Ã&nbsp; la derniÃ¨re ligne, que l'appel Ã&nbsp; la sÃ©quence de contrÃ´le \verb|\resultat| est ici possible puisque les sÃ©quences de contrÃ´le qu'elle contient sont dÃ©finies.\medskip

\subsection{DÃ©veloppement contrÃ´lÃ©, les macros  {\ttfamily\textbackslash StrExpand} et {\ttfamily\textbackslash scancs}}
\label{scancs}
La macro \verb|\StrExpand| dÃ©veloppe les tokens de la chaÃ®ne passÃ©e en argument. Voici sa syntaxe :\par\nobreak\medskip
\verb|\StrExpand|\arguC{nombre}\ARGU{chaine}\ARGU{nom}\smallskip

Le \argu{nombre} vaut 1 par dÃ©faut et reprÃ©sente le nombre de dÃ©veloppement(s) que doit subir la \argu{chaine} de tokens. Le \argu{nom} est le nom d'une sÃ©quence de contrÃ´le Ã&nbsp; laquelle est assignÃ© le rÃ©sultat, une fois que tous les tokens aient Ã©tÃ© dÃ©veloppÃ© le nombre de fois demandÃ©.\medskip

La macro opÃ¨re sÃ©quentiellement et par passe : chaque token est remplacÃ© par son 1-dÃ©velopement, et le token suivant subit le mÃªme traitement jusqu'Ã&nbsp; ce que la chaÃ®ne ait Ã©tÃ© parcourue. Ensuite, s'il reste des niveaux de dÃ©veloppement Ã&nbsp; faire, une nouvelle passe est initiÃ©e, et ainsi de suite jusqu'Ã&nbsp; ce que le nombre de dÃ©veloppements voulu aient Ã©tÃ© exÃ©cutÃ©s.\medskip

Voici un exemple :\par\nobreak\smallskip
\showcode+\def\csA{1 2}
\def\csB{a \csA}
\def\csC{\csB\space}
\def\csD{x{\csA y}\csB{\csC z}}
DÃ©veloppement de \string\csD\ au\par
\StrExpand[0]{\csD}{\csE} niveau 0 :
\detokenize\expandafter{\csE}\par
\StrExpand[1]{\csD}{\csE} niveau 1 :
\detokenize\expandafter{\csE}\par
\StrExpand[2]{\csD}{\csE} niveau 2 :
\detokenize\expandafter{\csE}\par
\StrExpand[3]{\csD}{\csE} niveau 3 :
\detokenize\expandafter{\csE}\par
\StrExpand[4]{\csD}{\csE} niveau 4 :
\detokenize\expandafter{\csE}+
\medskip

La macro agit sÃ©quentiellement et chaque token est dÃ©veloppÃ© isolÃ©ment sans tenir compte de ce qui suit. On ne peut donc dÃ©velopper que des tokens qui se suffisent Ã&nbsp; eux mÃªme et dont le dÃ©veloppement ne nÃ©cessite aucun autre token. Ainsi, \og\hbox{\verb|\iftrue A\else B\fi|}\fg, bien que se dÃ©veloppant en \guill{A} ne peut Ãªtre mis dans l'argument de \verb|\StrExpand|, et l'instruction :\par\nobreak\smallskip
\hfil\verb|\StrExpand{\iftrue A\else B\fi}\resultat|\hfil{}\par\nobreak\smallskip
fera Ã©chouer la compilation puisque le premier token \og\verb|\iftrue|\fg{} sera dÃ©veloppÃ© \emph{seul}, c'est-Ã&nbsp;-dire sans son \verb-\fi- correspondant, ce qui fÃ¢chera \TeX{} !\smallskip

Les rÃ¨gles habituelles de lecture des arguments sont en vigueur, Ã&nbsp; savoir qu'un espace suivant une sÃ©quence de contrÃ´le est ignorÃ©, et plusieurs espaces consÃ©cutifs n'en font qu'un. Ces rÃ¨gles ne s'appliquent pas pour des espaces explicitement demandÃ©s avec \verb-\space- ou \verb*-\ -\footnote{Ã€ ce propos, \texttt{\string\space} n'a pas la mÃªme signification que \texttt{\string\ }. La premiÃ¨re sÃ©quence de contrÃ´le se \emph{dÃ©veloppe} en un espace tandis que la deuxiÃ¨me est une primitive \TeX{} qui \emph{affiche} une espace. Comme toutes les primitives, cette derniÃ¨re est son propre dÃ©veloppement.}.\bigskip

On peut dÃ©tokeniser le rÃ©sultat obtenu par la macro \verb-\StrExpand- avec la macro \verb-\scancs- dont la syntaxe est :\par\nobreak\medskip
\verb|\scancs|\arguC{nombre}\ARGU{nom}\ARGU{chaine}\par\nobreak\smallskip

Le \argu{nombre} vaut 1 par dÃ©faut et reprÃ©sente le nombre de dÃ©veloppement(s) que doit subir chaque token constituant la \argu{chaine}. Le \argu{nom} est le nom d'une sÃ©quence de contrÃ´le Ã&nbsp; laquelle est assignÃ© le rÃ©sultat, une fois que tous les tokens aient Ã©tÃ© dÃ©veloppÃ©s le nombre de fois demandÃ© et ensuite dÃ©tokÃ©nisÃ©s.\smallskip

\verb-\scancs-  a Ã©tÃ© conservÃ©e pour garder une compatibilitÃ© avec des prÃ©cÃ©dentes versions de \Xstring. Pour les mÃªmes raisons, sa syntaxe n'est pas cohÃ©rente avec la syntaxe des autres macros. Cette macro, devenue triviale, prend le rÃ©sultat de \verb|\StrExpand| et lui applique simplement un \verb|\detokenize|.

\subsection{Ã€ l'intÃ©rieur d'une dÃ©finition de macro}
Avec le verbatim, certaines difficultÃ©s surviennent lorsque l'on se trouve Ã&nbsp; l'intÃ©rieur de la dÃ©finition d'une macro, c'est-Ã&nbsp;-dire entre les accolades suivant un \verb|\def\macro| ou un \verb|\newcommand\macro|.\medskip

Pour les mÃªmes raison qu'il est interdit d'employer la commande \verb|\verb| Ã&nbsp; l'intÃ©rieur de la dÃ©finition d'une macro, les arguments  verb du type |\argu{caractÃ¨res}| sont Ã©galement interdits, ce qui disqualifie la macro \verb|\verbtocs|. Il faut donc observer la rÃ¨gle suivante :\par\medskip
\hfill{\bfseries Ne pas utiliser la macro \verb-\verbtocs- Ã&nbsp; l'intÃ©rieur de la dÃ©finition d'une macro}.\hfill{}\bigskip

Mais alors, comment faire pour manipuler des arguments textuels verb et \guill{verbatimiser} dans les dÃ©finitions de macro ?\bigskip

Il y a la primitive \verb|\detokenize| de $\varepsilon$-\TeX, mais elle comporte des restrictions, entre autres :
\begin{itemize}
	\item les accolades doivent Ãªtre Ã©quilibrÃ©es;
	\item les espaces consÃ©cutifs sont ignorÃ©s;
	\item les signes \verb|%| sont interdits;
	\item une espace est ajoutÃ©e aprÃ¨s chaque sÃ©quence de contrÃ´le;
	\item le token \verb|#| devient \verb|##|.
\end{itemize}
\medskip

Il est prÃ©fÃ©rable d'utiliser la macro \verb|\scancs|, et dÃ©finir avec \verb|\verbtocs| Ã&nbsp; l'extÃ©rieur des dÃ©finitions de macros, des sÃ©quences de contrÃ´le contenant des caractÃ¨res spÃ©ciaux dÃ©tokÃ©nisÃ©s. On pourra aussi utiliser la macro \verb|\tokenize| pour transformer le rÃ©sultat final (qui est une chaÃ®ne de caractÃ¨res) en une sÃ©quence de contrÃ´le.\medskip

Dans l'exemple artificiel\footnote{On peut agir beaucoup plus simplement en utilisant la commande \texttt{\string\detokenize}. Il suffit de dÃ©finir la macro ainsi :\par\texttt{\string\newcommand\string\bracearg[1]\{\string\detokenize\{\{\#1\}\}\}}} qui suit, on Ã©crit une macro qui met son argument entre accolades. Pour cela, on dÃ©finit en dehors de la dÃ©finition de la macro 2 sÃ©quences de contrÃ´les \verb|\Ob| et \verb|\Cb| contenant une accolade ouvrante et une accolade fermante de catcodes 12. Ces sÃ©quences de contrÃ´le sont ensuite dÃ©veloppÃ©es et utilisÃ©es Ã&nbsp; l'intÃ©rieur de la macro pour obtenir le rÃ©sultat voulu :\par\nobreak\medskip
\showcode+\verbtocs{\Ob}|{|
\verbtocs{\Cb}|}|
\newcommand\bracearg[1]{%
	\def\text{#1}%
	\scancs{\result}{\Ob\text\Cb}%
	\result}

\bracearg{xstring}\par
\bracearg{\a}+

\subsection{La macro \ttfamily\textbackslash StrRemoveBraces}
Pour des utilisations spÃ©ciales, on peut dÃ©sirer retirer les accolades dÃ©limitant les groupes dans un argument.

On peut utiliser la macro \verb|\StrRemoveBraces| dont voici la syntaxe :\par\nobreak\smallskip

\verb|\StrRemoveBraces|\ARGU{chaine}\arguC{nom}
\smallskip

Cette macro est sensible au mode d'exploration, et retirera \emph{toutes} les accolades avec \verb|\exploregroups| alors qu'elle ne retirera que les accolades des groupes de plus bas niveau avec \verb|\noexploregroups|.\medskip

\showcode+\noexploregroups
\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
\meaning\mycs

\exploregroups
\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
\meaning\mycs+
\begin{center}
$\star$\par
$\star$\quad$\star$
\end{center}

C'est tout, j'espÃ¨re que ce package vous sera utile !\par\nobreak
Merci de me signaler par \href{mailto:unbonpetit@netc.fr}{email} tout bug ou toute proposition d'amÃ©lioration\ldots\par\nobreak\bigskip
Christian \textsc{Tellechea}
\end{document}</pre></body></html>