xstring 1.5 (31dec08)

git-svn-id: svn://tug.org/texlive/trunk@11796 c570f23f-e606-0410-a88d-b1316a301751

9 files changed, 1377 insertions, 814 deletions

diff --git a/Master/texmf-dist/doc/generic/xstring/README b/Master/texmf-dist/doc/generic/xstring/README
index 0fc7ebf61d5..49f0f106950 100644
--- a/Master/texmf-dist/doc/generic/xstring/README
+++ b/Master/texmf-dist/doc/generic/xstring/README
@@ -1,18 +1,20 @@
                               _________________
 
                                xstring package
-                                    v1.4b
-                                 2008/11/16
+                                    v 1.5
+                                 2008/12/31
                               _________________
 
 ------------------------------------------------------------------------------
                                     Warning!
-This package does not require LaTeX (although eTeX is still required).
-Consequently, the xstring.tex file should be installed in the tex/ subtree.
+    This package does not require LaTeX (although eTeX is still required).
+  Consequently, the xstring.tex file should be installed in the tex/ subtree.
 ------------------------------------------------------------------------------
 This package provides macros manipulating strings for programming use.
-A "string" is made of chars (catcodes 10, 11 and 12), controls sequences,
-groups between braces, tokens with other catcodes excepted 6 and 14 (# and %).
+A "string" is made of TeX code, i.e. chars (catcodes 10, 11 and 12), controls
+sequences, groups between braces, tokens with other catcodes, excepted catcodes
+6 and 14 (usually tokens # and %).
+
 Main features are:
   * tests:
      - does a string contains at least n times an another?
@@ -25,14 +27,16 @@ Main features are:
        substring;
      - what is between the occurrences of 2 substrings;
      - substring between 2 positions;
-     - split a string, etc.
+     - split a string;
+     - find a group with its identifier, etc.
   * substitution of all (or the n first) occurrences of a substring
     for an other substring;
   * calculation of numbers:
      - length of a string;
      - position of the nth occurrence of a substring;
      - how many times a string contains a substring?
-     - comparison of strings: position of the first difference.
+     - comparison of strings: position of the first difference;
+     - identifier of the group in which a macro worked.
 
 For advanced programming needs, other macros allow to use other special
 characters forbiden in strings (#  %).
@@ -57,9 +61,11 @@ répertoire tex/.
 ------------------------------------------------------------------------------
 Cette extension regroupe un ensemble de macros manipulant des chaînes à des
 fins de programmation.
-Une "chaine" pouvant contenir des caractères, des séquences de contrôle, des
-groupes entre accolades et des lexèmes ayant d'autres catcodes excepté 6 et 14
-(# et %).
+Une "chaine" est du code TeX, c'est-à-dire des caractères (catcodes 10, 11
+et 12), des séquences de contrôle, des groupes entre accolades et des lexèmes
+ayant d'autres catcodes excepté les catcodes 6 et 14 (habituellement les 
+lexèmes # et %).
+
 Les principales fonctionnalités sont :
   * des tests :
      - une chaîne en contient elle une autre au moins n fois ?
@@ -72,19 +78,21 @@ Les principales fonctionnalités sont :
        d'une sous-chaîne;
      - renvoi de ce qui se trouve entre les occurrences de 2 sous-chaînes;
      - sous-chaîne comprise entre 2 positions;
-     - coupure d'une chaîne, etc.
+     - coupure d'une chaîne;
+     - recherche d'un groupe avec son identifiant.
   * le remplacement de toutes ou des n premières occurrences d'une
     sous-chaîne par une autre sous-chaîne;
   * des calculs de nombres :
      - longueur d'une chaîne;
      - position de la la nieme occurrence d'une sous-chaîne;
-     - comptage du nombre d'occurrences d'une sous-chaîne dans une autre.
-     - comparaison de 2 chaînes : position du 1er caractère différent.
+     - comptage du nombre d'occurrences d'une sous-chaîne dans une autre;
+     - comparaison de 2 chaînes : position de la 1ere différence;
+     - identifiant du groupe dans lequel les macros ont opéré.
 
 Pour des méthodes de programmation avancées, d'autres commandes permettent
 d'utiliser les caractères spéciaux interdits dans les chaines (# %).
 
-Ce paquet contient 11 fichiers :
+Ce paquet contient 11 fichiers suivants :
   * xstring.sty (le fichier sty pour LaTeX)
   * xstring.tex (le package lui même)
   * xstring_doc_en.tex and xstring_doc_en.pdf (manuel en anglais)
diff --git a/Master/texmf-dist/doc/generic/xstring/test_etex.pdf b/Master/texmf-dist/doc/generic/xstring/test_etex.pdf
index 69fdb0fe788..91ac4ada3dd 100644
--- a/Master/texmf-dist/doc/generic/xstring/test_etex.pdf
+++ b/Master/texmf-dist/doc/generic/xstring/test_etex.pdf
diff --git a/Master/texmf-dist/doc/generic/xstring/test_latex.pdf b/Master/texmf-dist/doc/generic/xstring/test_latex.pdf
index ca71e773cbb..c35dbe1f3c9 100644
--- a/Master/texmf-dist/doc/generic/xstring/test_latex.pdf
+++ b/Master/texmf-dist/doc/generic/xstring/test_latex.pdf
diff --git a/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.pdf b/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.pdf
index d8d6ddc6057..6406ead0bb5 100644
--- a/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.pdf
+++ b/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.pdf
diff --git a/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.tex b/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.tex
index 0dd3ecaa4ec..2c09848b6e8 100644
--- a/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.tex
+++ b/Master/texmf-dist/doc/generic/xstring/xstring_doc_en.tex
@@ -1,6 +1,6 @@
 % This is xtring_doc_en.tex, the english manual of xstring
 %
-% Christian Tellechea 2008
+% Christian Tellechea 2009
 %
 % email : unbonpetit@gmail.com
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -17,8 +17,8 @@
 \documentclass[a4paper,10pt]{article}
 \usepackage[utf8]{inputenc}
 \usepackage[T1]{fontenc}
-\usepackage[dvips,colorlinks=true,hyperfootnotes=false,citecolor=black,filecolor=black,linkcolor=blue,urlcolor=blue,bookmarks=false,pdfauthor={Christian Tellechea},pdftitle={xstring},pdfsubject={package for strings},pdfkeywords={xstring,latex,string},pdfcreator={LaTeX}]{hyperref}
-\usepackage[a4paper,dvips,margin=2cm]{geometry}
+\usepackage[dvips,colorlinks=true,hyperfootnotes=false,citecolor=black,filecolor=black,linkcolor=blue,urlcolor=blue,bookmarks=false,pdfauthor={Christian Tellechea},pdftitle={xstring},pdfsubject={package for strings of tokens},pdfkeywords={xstring,latex,string},pdfcreator={LaTeX}]{hyperref}
+\usepackage[a4paper,dvips,margin=1.9cm]{geometry}
 \usepackage{amsmath,amssymb}
 \usepackage{textcomp}
 \usepackage{moreverb}
@@ -28,8 +28,8 @@
 \usepackage{xstring}
 \usepackage[french,english]{babel}
 \makeatletter
-\newcommand*\exemple{\@ifstar{\def\frontiere{|}\@xs@MakeVerb}{\def\frontiere{}\@xs@MakeVerb}}
-\long\def\@xs@afterreadverb#1{%
+\newcommand*\exemple{\@ifstar{\let\frontiere\textbar\@xs@MakeVerb}{\let\frontiere\@empty\@xs@MakeVerb}}
+\def\@xs@afterreadverb#1{%
 	\normalexpandarg
 	\tokenize\cs@resultat{#1}%
 	\fullexpandarg
@@ -80,7 +80,7 @@
 		\begin{minipage}{0.85\linewidth}
 			\noindent
 			\hfill\textbf{\textit{Abstract}}\hfill{}\medskip\par
-			This package which requires $\varepsilon$-\TeX{}, provides macros manipulating strings contaning chars, control sequences, groups between braces and other special tokens so that the macros may be used for programming purposes. Main features are
+			This package which requires $\varepsilon$-\TeX{}, provides macros manipulating strings of tokens. For a basic use, tokens can be alphanumeric chars, but the macros can also be useful for manipulating tokens, i.e. \TeX{} code. Main features are:
 			\parindent1.5em
 			\begin{itemize}
 				\item[$\triangleright$] tests:
@@ -94,7 +94,8 @@
 					\begin{itemize}
 						\item what is on the left (or the right) of the $n$\th occurrence of a substring;
 						\item what is between the occurrences of 2 substrings;
-						\item substring between 2 positions, etc.
+						\item substring between 2 positions;
+						\item serach of a group with its identifier.
 					\end{itemize}
 				\item[$\triangleright$] substitution of all, or the $n$ first occurrences of a substring for an other substring;
 				\item[$\triangleright$] calculation of numbers:
@@ -102,7 +103,8 @@
 						\item length of a string;
 						\item position of the $n$\th occurrence of a substring;
 						\item how many times a string contains a substring?
-						\item comparison of 2 strings: position of the first difference.
+						\item comparison of 2 strings: position of the first difference;
+						\item identifier of the group in which a macro made a cut or a search.
 					\end{itemize}
 			\end{itemize}
 			\parindent0pt
@@ -112,19 +114,17 @@
 	\end{center}
 	\hrulefill\vfill{}
 \end{titlepage}
-\pagebreak
+
 \tableofcontents
-\pagebreak
 
 This manual is a translation of the french manual. I apologize for my poor english but I did my best\footnote{Any email to tell me errors would be appreciated!}, and I hope that the following is comprehensible!
 \section{Presentation}
 \subsection{Description}
-This extension\footnote{This extension does not require \LaTeX{} and can be compiled with Plain $\varepsilon$-\TeX{}.} provides macros and tests operating on strings of \TeX{} code, as other programmation languages have. They provides the usual strings operations, such as: test if a string contains another, begins or ends with another, extractions of strings, calculation of the position of a substring, of the number of occurrences, etc.\medskip
-
+This extension\footnote{This extension does not require \LaTeX{} and can be compiled with Plain $\varepsilon$-\TeX{}.} provides macros and tests operating on strings of tokens, i.e. \TeX{} code, as other programmation languages have. They provides the usual strings operations, such as: test if a string contains another, begins or ends with another, extractions of strings, calculation of the position of a substring, of the number of occurrences, etc.\medskip
 
 \Xstring reads the arguments of the macros \US by \US\footnote{In the \TeX{} code, a \US is a control sequence, a group between brace or a single char. See also page~\pageref{developpementarguments}.} : when \USs are \guill{simple} chars (catcode 10, 11 and 12), \Xstring logically read the argument char by char. \Xstring can also be used for programming purpose, including in arguments other tokens such as control sequences, braces and tokens with other catcodes. See chapter on reading mode and arguments expansion (page~\pageref{developpementarguments}), the command \verb|\verbtocs| (page~\pageref{verbtocs}) and the command \verb|\scancs| (page~\pageref{scancs}).\medskip
 
-As the arguments may contain chars, advanced users could have problems with catcodes leading to unexpected behaviours. These behaviours can be controlled: read page~\pageref{macrosetoilees}.\medskip
+As the arguments may contain any token, advanced users could have problems with catcodes leading to unexpected behaviours. These behaviours can be controlled: read page~\pageref{macrosetoilees}.\medskip
 
 Certainly, other packages exist (for example \href{http://www.ctan.org/tex-archive/macros/latex/contrib/substr/}{\nolinkurl{substr}} and \href{http://www.ctan.org/tex-archive/macros/latex/contrib/stringstrings/}{\nolinkurl{stringstrings}}), but as well as differences on features, they do not take into account occurrences so I found them too limited and difficult to use for programming.
 
@@ -134,7 +134,11 @@ I decided to write this package of macros because I have never really found tool
 Thus, writing a coherent set of macros forces more discipline and leads to necessary improvements, which took most of the time I spent writing this package. This package is my first one as I recently discoverd \LaTeX{}\footnote{In november 2007, I will be a noob for a long time\ldots}, so my main motivation was to make progress in programming with \TeX, and to tackle its specific methods.
 
 \section{The macros}
+\textbf{Important}: in the following, a \argu{number} can be an integer written with numeric chars, a counter, or the result of an arithmetic operation made with the command \verb|\numexpr|.
+
 \subsection{Presentation of macros}
+For a better understanding, let's see first the macros with the simpler arguments possible. No special catcode, no exotic token, no control sequence neither: only alphanumeric chars will be contained in the arguments.\medskip
+
 In the following chapters, all the macros will be presented this plan:
 \begin{itemize}
 	\item the syntax\footnote{The optional star, the optional argument in last position will be explained later. See page~\pageref{macrosetoilees} for starred macros and  page~\pageref{argumentoptionnel} for the optional argument.} and the value of optional arguments
@@ -248,7 +252,7 @@ Tests if \argu{string} ends with \argu{stringA}, and runs \argu{true} if so, and
 
 \subsubsection{\ttfamily\textbackslash IfInteger}
 
-\verb|\IfInteger|\etoile\ARGU{number}\ARGU{true}\ARGU{false}
+\verb|\IfInteger|\ARGU{number}\ARGU{true}\ARGU{false}
 \smallskip
 
 Tests if \argu{number} is an integer, and runs \argu{true} if so, and \argu{false} otherwise.\smallskip
@@ -267,7 +271,7 @@ If test is false because unexpected characters, the control sequence \verb|\@xs@
 
 \subsubsection{\ttfamily\textbackslash IfDecimal}\label{ifdecimal}
 
-\verb|\IfDecimal|\etoile\ARGU{number}\ARGU{true}\ARGU{false}
+\verb|\IfDecimal|\ARGU{number}\ARGU{true}\ARGU{false}
 \smallskip
 
 Tests if \argu{number} is a decimal, and runs \argu{true} if so, and \argu{false} otherwise.\smallskip
@@ -302,7 +306,7 @@ If test is false because unexpected characters, the control sequence \verb|\@xs@
 \verb|\IfStrEq|\etoile\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
 \smallskip
 
-Tests if the strings \argu{stringA} and \argu{stringB} are equal, i.e. if they contain successively the same characters in the same order. Runs \argu{true} if so, and \argu{false} otherwise.\smallskip
+Tests if the strings \argu{stringA} and \argu{stringB} are equal, i.e. if they contain successively the same \USs in the same order. Runs \argu{true} if so, and \argu{false} otherwise.\smallskip
 
 \exemple|\IfStrEq{a1b2c3}{a1b2c3}{true}{false}|
 \exemple|\IfStrEq{abcdef}{abcd}{true}{false}|
@@ -315,7 +319,7 @@ Tests if the strings \argu{stringA} and \argu{stringB} are equal, i.e. if they c
 
 \subsubsection{\ttfamily\textbackslash IfEq}
 
-\verb|\IfEq|\etoile\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
+\verb|\IfEq|\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
 \smallskip
 
 Tests if the strings \argu{stringA} and \argu{stringB} are equal, \emph{except} if both \argu{stringA} and \argu{stringB} contain numbers in which case the macro tests if these numbers are equal. Runs \argu{true} if so, and \argu{false} otherwise.\smallskip
@@ -323,8 +327,7 @@ Tests if the strings \argu{stringA} and \argu{stringB} are equal, \emph{except}
 \begin{Conditions}
 	\item The definition of \emph{number} is given with the macro \verb|IfDecimal| (see page~\pageref{ifdecimal}), and thus :
 	\item \guill{+} signs are optional;
-	\item Decimal separator can be a dot or a comma;
-	\item It is possible to evaluate an algebric expression with the $\varepsilon$-\TeX{} primitive \verb|\numexpr|, keeping in mind that it operate on integers only, and that results of divisions are \emph{rounded} and not truncated!
+	\item Decimal separator can be a dot or a comma.
 \end{Conditions}
 
 \exemple|\IfEq{a1b2c3}{a1b2c3}{true}{false}|
@@ -352,7 +355,7 @@ Tests if the strings \argu{stringA} and \argu{stringB} are equal, \emph{except}
 \end{minipage}
 \smallskip
 
-Tests successively if \argu{string} is equal to \argu{string1}, \argu{string2}, etc. Comparison is made with \verb|\IfStrEq| (see above). If the test $i$ is positive (the \argu{string} matches \argu{string\;$i$}), the macro runs \argu{code\;$i$} and ends. If all tests fail, the macro runs the optional \argu{other cases code}, if present.\smallskip
+Tests successively if \argu{string} is equal to \argu{string1}, \argu{string2}, etc. Comparison is made with \verb|\IfStrEq| (see above). If the test number $i$ is positive (the \argu{string} matches \argu{string\;$i$}), the macro runs \argu{code\;$i$} and ends. If all tests fail, the macro runs the optional \argu{other cases code}, if present.\smallskip
 
 \exemple|\IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}|
 \exemple*|\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|
@@ -372,7 +375,7 @@ Tests successively if \argu{string} is equal to \argu{string1}, \argu{string2},
 \end{minipage}
 \smallskip
 
-Tests successively if \argu{string} is equal to \argu{string1}, \argu{string2}, etc. Comparison is made with \verb|\IEq| (see above). If the test $i$ is positive (the \argu{string} matches \argu{string\;$i$}), the macro runs \argu{code\;$i$} and ends. If all tests fail, the macro runs the optional \argu{other cases code}, if present.\smallskip
+Tests successively if \argu{string} is equal to \argu{string1}, \argu{string2}, etc. Comparison is made with \verb|\IEq| (see above). If the test number $i$ is positive (the \argu{string} matches \argu{string\;$i$}), the macro runs \argu{code\;$i$} and ends. If all tests fail, the macro runs the optional \argu{other cases code}, if present.\smallskip
 
 \exemple|\IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}|
 \exemple*|\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|
@@ -460,7 +463,7 @@ In \argu{string}, returns the substring between\footnote{In a strict sense, i.e.
 
 \subsubsection{\ttfamily\textbackslash StrSubstitute}
 
-\verb|\StrSubstitute|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\arguC{name}
+\verb|\StrSubstitute|\arguC{number}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\arguC{name}
 \smallskip
 
 The value of the optional argument \argu{number} is 0 by default.\par\smallskip
@@ -508,31 +511,8 @@ Delete the \argu{number} first occurrences of \argu{stringA} in \argu{string}, e
 \exemple|\StrDel[9]{abracadabra}{a}|
 \exemple|\StrDel{a bc def }{ }|
 
-\subsubsection{\ttfamily\textbackslash StrSplit}
-\verb|\StrSplit|\etoile\ARGU{string}\ARGU{number}\ARGU{csA}\ARGU{csB}
-\smallskip
-
-The \argu{string}, is splitted after the character at position \argu{number}. The left part is assigned to the control sequence \argu{csA} and the right part is assigned to \argu{csB}.\par
-This macro returns two strings, so it does \emph{not} display anything. Consequently, it does not provide the optional argument in last position.\medskip
-
-\begin{Conditions}
-	\item If \argu{number}${}\leqslant0$, \argu{csA} is empty and \argu{csB} is equal to \argu{string};
-	\item If \argu{number}${}\geqslant$\argu{lengthString}, \argu{csA} is equal to \argu{string} and \argu{csB} is empty;
-	\item If \argu{string} is empty, \argu{csA} and \argu{csB} are empty, whatever be the integer \argu{number}.
-\end{Conditions}
-
-\setverbdelim{=}
-\exemple=\StrSplit{abcdef}{4}{\aa}{\bb}results: |\aa| and |\bb|=
-\exemple=\StrSplit{a b c }{2}{\aa}{\bb}results: |\aa| and |\bb|=
-\exemple=\StrSplit{abcdef}{1}{\aa}{\bb}results: |\aa| and |\bb|=
-\exemple=\StrSplit{abcdef}{5}{\aa}{\bb}results: |\aa| and |\bb|=
-\exemple=\StrSplit{abcdef}{9}{\aa}{\bb}results: |\aa| and |\bb|=
-\exemple=\StrSplit{abcdef}{-3}{\aa}{\bb}results: |\aa| and |\bb|=
-\setverbdelim{|}
-
 \subsubsection{\ttfamily\textbackslash StrGobbleLeft}
-
-\verb|\StrGobbleLeft|\etoile\ARGU{string}\ARGU{number}\arguC{name}
+\verb|\StrGobbleLeft|\ARGU{string}\ARGU{number}\arguC{name}
 \smallskip
 
 In \argu{string}, delete the \argu{number} first characters on the left.\medskip
@@ -551,7 +531,7 @@ In \argu{string}, delete the \argu{number} first characters on the left.\medskip
 
 \subsubsection{\ttfamily\textbackslash StrLeft}
 
-\verb|\StrLeft|\etoile\ARGU{string}\ARGU{number}\arguC{name}
+\verb|\StrLeft|\ARGU{string}\ARGU{number}\arguC{name}
 \smallskip
 
 In \argu{string}, returns the \argu{number} first characters on the left.\medskip
@@ -570,7 +550,7 @@ In \argu{string}, returns the \argu{number} first characters on the left.\medski
 
 \subsubsection{\ttfamily\textbackslash StrGobbleRight}
 
-\verb|\StrGobbleRight|\etoile\ARGU{string}\ARGU{number}\arguC{name}
+\verb|\StrGobbleRight|\ARGU{string}\ARGU{number}\arguC{name}
 \smallskip
 
 In \argu{string}, delete the \argu{number} last characters on the right.\medskip
@@ -583,7 +563,7 @@ In \argu{string}, delete the \argu{number} last characters on the right.\medskip
 
 \subsubsection{\ttfamily\textbackslash StrRight}
 
-\verb|\StrRight|\etoile\ARGU{string}\ARGU{number}\arguC{name}
+\verb|\StrRight|\ARGU{string}\ARGU{number}\arguC{name}
 \smallskip
 
 In \argu{string}, returns the \argu{number} last characters on the right.\medskip
@@ -599,7 +579,7 @@ In \argu{string}, returns the \argu{number} last characters on the right.\medski
 \verb|\StrChar|\etoile\ARGU{string}\ARGU{number}\arguC{name}
 \smallskip
 
-Returns the character at the position \argu{number} in \argu{string}.\medskip
+Returns the \US at the position \argu{number} in \argu{string}.\medskip
 
 \begin{Conditions}
 \item If \argu{string} is empty, no caracter is returned;
@@ -613,7 +593,7 @@ Returns the character at the position \argu{number} in \argu{string}.\medskip
 
 \subsubsection{\ttfamily\textbackslash StrMid}
 
-\verb|\StrMid|\etoile\ARGU{string}\ARGU{numberA}\ARGU{numberB}\arguC{name}
+\verb|\StrMid|\ARGU{string}\ARGU{numberA}\ARGU{numberB}\arguC{name}
 \smallskip
 
 In \argu{string}, returns the substring between\footnote{In the broad sense, i.e. that the strings characters of the \guill{border} are returned.} the positions \argu{numberA} and \argu{numberB}.\medskip
@@ -634,10 +614,10 @@ In \argu{string}, returns the substring between\footnote{In the broad sense, i.e
 \exemple|\StrMid{xstring}{3}{3}|
 \exemple*|\StrMid{a bc def }{2}{7}|
 
-\subsection{Number results}
+\subsection{Macros returning a number}
 \subsubsection{\ttfamily\textbackslash StrLen}
 
-\verb|\StrLen|\etoile\ARGU{string}\arguC{name}
+\verb|\StrLen|\ARGU{string}\arguC{name}
 \smallskip
 
 Return the length of \argu{string}.
@@ -648,7 +628,7 @@ Return the length of \argu{string}.
 
 \subsubsection{\ttfamily\textbackslash StrCount}
 
-\verb|\StrCount|\etoile\ARGU{string}\ARGU{stringA}\arguC{name}
+\verb|\StrCount|\ARGU{string}\ARGU{stringA}\arguC{name}
 \smallskip
 
 Counts how many times \argu{stringA} is contained in \argu{string}.\par\medskip
@@ -664,7 +644,7 @@ Counts how many times \argu{stringA} is contained in \argu{string}.\par\medskip
 
 \subsubsection{\ttfamily\textbackslash StrPosition}
 
-\verb|\StrPosition|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
+\verb|\StrPosition|\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
 \smallskip
 
 The value of the optional argument \argu{number} is 1 by default.\par\smallskip
@@ -689,11 +669,11 @@ In \argu{string}, returns the position of the \argu{number}\th occurrence of \ar
 \verb|\StrCompare|\etoile\ARGU{stringA}\ARGU{stringB}\arguC{name}
 \smallskip
 
-This macro has 2 tolerances: the "normal" tolerance, used bu default, and the "strict" tolerance.
+This macro has 2 tolerances: the "normal" tolerance, used by default, and the "strict" tolerance.
 \begin{itemize}
-	\item The normal tolerance, activated with \verb|\comparenormal|.\par
+	\item The normal tolerance is activated with \verb|\comparenormal|.\par
 	The macro compares characters from left to right in \argu{stringA} and \argu{stringB} until a difference appears or the end of the shortest string is reached. The position of the first difference is returned and if no difference is found, the macro return 0.
-	\item The strict tolerance, activated with \verb|\comparestrict|.\par
+	\item The strict tolerance is activated with \verb|\comparestrict|.\par
 	The macro compares the 2 strings. If they are equal, it returns 0. If not, the position of the first difference is returned.
 \end{itemize}
 \medskip
@@ -728,15 +708,58 @@ Examples with the strict tolerance:\par\comparestrict
 \subsection{Expansion of arguments}
 \label{devarg}
 \subsubsection{The commands {\ttfamily \textbackslash fullexpandarg}, {\ttfamily \textbackslash expandarg} and {\ttfamily \textbackslash noexpandarg}}
-The command \verb|\fullexpandarg| is called by default, so all the arguments are fully expanded (an \verb|\edef| is used) before the the macro is called. In most of the cases, this expansion mode avoids chains of \verb|\expandafter| and allows lighter code.
+The command \verb|\fullexpandarg| is called by default, so all the arguments are fully expanded (an \verb|\edef| is used) before the the macro works on them. In most of the cases, this expansion mode avoids chains of \verb|\expandafter| and allows lighter code.
 
 Of course, the expansion of argument can be canceled to find back the usual behaviour of \TeX{} with the comands \verb|\noexpandarg| or \verb|\normalexpandarg|.\medskip
 
-An other expansion mode can be called with \verb|\expandarg|. In this case, the \textbf{first token} of each argument is expanded \emph{one time} while all other tokens are left unchanged (for the expansion of all tokens one time, you should call the macro \verb|\scancs*|, see page~\pageref{scancs}).\medskip
+Another expansion mode can be called with \verb|\expandarg|. In this case, the \textbf{first token} of each argument is expanded \emph{one time} while all other tokens are left unchanged (if you want the expansion of all tokens one time, you should call the macro \verb|\scancs*|, see page~\pageref{scancs}).\medskip
+
+The commands \verb|\fullexpandarg|, \verb|\noexpandarg|, \verb|\normalexpandarg| and \verb|\expandarg| can be called at any moment in the code; they behave as "switches" and they can be locally used in a group.\medskip
 
-The commands \verb|\fullexpandarg|, \verb|\noexpandarg|, \verb|\normalexpandarg| and \verb|\expandarg| can be called at any moment in the code; they behave as "switches". They can be locally used in a group.\medskip
+It is possible to save the expansion mode with \verb|\saveexpandmode|, then modify this expansion mode and come back to the situation when it was saved with \verb|\restoreexpandmode|.\medskip
 
-It is possible to save the expansion mode with \verb|\saveexpandmode|, then modify this expansion mode and come back to the situation when it was saved with \verb|\restoreexpandmode|.
+In the following list, for every macro of the previous chapter, the arguments colored in \textcolor{red}{red} will possibly be expanded, according to the expansion mode:\smallskip
+
+\newcommand\colorise{\color{red}}
+\parindent3em
+\begin{itemize}
+	\item\verb|\IfSubStr|\etoile{\colorise\arguC{number}\ARGU{string}\ARGU{stringA}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfSubStrBefore|\etoile{\colorise\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfSubStrBehind|\etoile{\colorise\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfBeginWith|\etoile{\colorise\ARGU{string}\ARGU{stringA}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfEndWith|\etoile{\colorise\ARGU{string}\ARGU{stringA}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfInteger|{\colorise\ARGU{number}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfDecimal|{\colorise\ARGU{number}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfStrEq|\etoile{\colorise\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfEq|\etoile{\colorise\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfStrEqCase|\etoile{\colorise\ARGU{string}\texttt{\color{black}\{}\colorise\ARGU{string1}}\ARGU{code1}\par
+		\setbox0=\hbox{{\ttfamily\string\IfStrEqCase}\etoile\ARGU{string}{\ttfamily\{}}
+		\hskip\wd0{\colorise\ARGU{string2}}\ARGU{code2}\par
+		\hskip\wd0\ \ldots\par
+		\hskip\wd0{\colorise\ARGU{string $n$}}\ARGU{code $n$}\verb|}|\arguC{other cases code}
+	\item\verb|\IfEqCase|\etoile{\colorise\ARGU{string}\texttt{\color{black}\{}\colorise\ARGU{string1}}\ARGU{code1}\par
+		\setbox0=\hbox{{\ttfamily\string\IfEqCase}\etoile\ARGU{string}{\ttfamily\{}}
+		\hskip\wd0{\colorise\ARGU{string2}}\ARGU{code2}\par
+		\hskip\wd0\ \ldots\par
+		\hskip\wd0{\colorise\ARGU{string $n$}}\ARGU{code $n$}\verb|}|\arguC{other cases code}
+	\item\verb|\StrBefore|\etoile{\colorise\arguC{number}\ARGU{string}\ARGU{stringA}}\arguC{name}
+	\item\verb|\StrBehind|\etoile{\colorise\arguC{number}\ARGU{string}\ARGU{stringA}}\arguC{name}
+	\item\verb|\StrBetween|\etoile{\colorise\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}}\arguC{name}
+	\item\verb|\StrSubstitute|{\colorise\arguC{number}\ARGU{string}\ARGU{stringA}\ARGU{stringB}}\arguC{name}
+	\item\verb|\StrDel|{\colorise\arguC{number}\ARGU{string}\ARGU{stringA}}\arguC{name}
+	\item\verb|\StrSplit|{\colorise\ARGU{string}\ARGU{number}}\ARGU{stringA}\ARGU{stringB}\qquad{\small(see macro \verb|StrSplit| page~\pageref{StrSplit})}
+	\item\verb|\StrGobbleLeft|{\colorise\ARGU{string}\ARGU{number}}\arguC{name}
+	\item\verb|\StrLeft|{\colorise\ARGU{string}\ARGU{number}}\arguC{name}
+	\item\verb|\StrGobbleRight|{\colorise\ARGU{string}\ARGU{number}}\arguC{name}
+	\item\verb|\StrRight|{\colorise\ARGU{string}\ARGU{number}}\arguC{name}
+	\item\verb|\StrChar|{\colorise\ARGU{string}\ARGU{number}}\arguC{name}
+	\item\verb|\StrMid|{\colorise\ARGU{string}\ARGU{number1}\ARGU{number2}}\arguC{name}
+	\item\verb|\StrLen|{\colorise\ARGU{string}}\arguC{name}
+	\item\verb|\StrCount|{\colorise\ARGU{string}\ARGU{stringA}}\arguC{name}
+	\item\verb|\StrPosition|{\colorise\arguC{number}\ARGU{string}\ARGU{stringA}}\arguC{name}
+	\item\verb|\StrCompare|{\colorise\ARGU{stringA}\ARGU{stringB}}\arguC{name}
+\end{itemize}
+\parindent0pt
 
 \subsubsection{Chars allowed in arguments}
 First of all, whatever be the current expansion mode, \textbf{tokens with catcode 6 and 14 (usually {\ttfamily\#} and {\ttfamily\%}) are forbidden in all the arguments}\footnote{Maybe, the token {\ttfamily\#} will be allowed in a further version.}.\bigskip
@@ -763,28 +786,28 @@ When expansion is not full (\verb|\expandarg| or \verb|\noexpandarg| are active)
 
 \subsection{Expansion of macros, optional argument}
 \label{argumentoptionnel}
-The macros of this package are not purely expandable, i.e. they cannot be put in the argument of an \verb|\edef|. Nestling macros is not possible neither, even with \verb|\expandafter|.\medskip
+The macros of this package are not purely expandable, i.e. they cannot be put in the argument of an \verb|\edef|. Nestling macros is not possible neither.\medskip
 
-For this reason, all the macros returning a result (i.e. all excepted the tests and \verb|\StrSplit|) have an optional argument in last position. The syntax is \arguC{name}, where \argu{name} is the name of the control sequence that will receive the result of the macro: the assignment is made with an \verb|\edef| which make the result of the macro \argu{name} purely expandable. Of course, if an optional argument is present, the macro does not display anything.\medskip
+For this reason, all the macros returning a result (i.e. all excepted the tests) have an optional argument in last position. The syntax is \arguC{name}, where \argu{name} is the name of the control sequence that will receive the result of the macro: the assignment is made with an \verb|\edef| which make the result of the macro \argu{name} purely expandable. Of course, if an optional argument is present, the macro does not display anything.\medskip
 
 Thus, this structure not allowed, supposed to assign to \verb|\Result| the 4 chars on the left of \verb|xstring|:\par
 \hspace{0.2\linewidth}\verb|\edef\Result{\StrLeft{xstring}{4}}|\par
 \qquad is equivalent to :\par
 \hspace{0.2\linewidth}\verb|\StrLeft{xstring}{4}[\Result]|\medskip
 
-And this not allowed nested structure, supposed to remove the first and last char of  \verb|xstring|:\par
+And this not allowed nested structure, supposed to remove the first and last char of \verb|xstring|:\par
 \hspace{0.2\linewidth}\verb|\StrGobbleLeft{\StrGobbleRight{xstring}{1}}{1}|\par
-\qquad can be written like this:\par
+\qquad should be written like this:\par
 \hspace{0.2\linewidth}\verb|\StrGobbleRight{xstring}{1}[\mystring]|\par
 \hspace{0.2\linewidth}\verb|\StrGobbleleft{\mystring}{1}|\par
 
 \subsection{How does \Xstring read the arguments?}
 \label{developpementarguments}
 \subsubsection{Syntax unit by \US}
-The macros of \Xstring read their arguments \US par \US. In the \TeX{} code, a \US is either:\parindent3em
+The macros of \Xstring read their arguments \US par \US. In the \TeX{} code, a \US\footnote{For advanced users used to \LaTeX{} programming, a \US is what is gobbled by the macro \texttt{\string\@gobble} whose code is: {\ttfamily\string\def\string\@gobble\string#1\string{\string}}} is either:\parindent3em
 \begin{itemize}
 	\item a control sequence;
-	\item a group, i.e. what is between 2 balanced braces;
+	\item a group, i.e. what is between 2 balanced braces (usually tokens catcode 1 and 2);
 	\item a char.
 \end{itemize}
 \medskip\parindent0pt
@@ -793,7 +816,7 @@ Let's see what is a \US with an example. Let's take this argument : "\verb|ab\te
 
 It has 6 \USs: "\verb|a|", "\verb|b|", "\verb|\textbf|", "\verb|{xyz}|", "\verb|c|" and "\verb|d|".\medskip
 
-What will happen while \verb|\noexpandarg| is active, we ask \Xstring to find the length of this argument and find its 4\th "char'?\medskip
+What will happen if, while \verb|\noexpandarg| is active, we ask \Xstring to find the length of this argument and find its 4\th "char"\medskip
 
 \begin{minipage}[r]{0.6\linewidth}
 \hfill
@@ -814,14 +837,14 @@ What will happen while \verb|\noexpandarg| is active, we ask \Xstring to find th
 \fullexpandarg
 \medskip
 
-It is necessary to use \verb|\meaning| to see the real expansion of \verb|\mychar|, and not simply call \verb|\mychar| which make loose informations (braces here). We do not obtain a "char" but a \US, as expected.
+It is necessary to use \verb|\meaning| to see the real expansion of \verb|\mychar|, and not simply call \verb|\mychar| to display it, which make loose informations (braces here). We do not obtain a "char" but a \US, as expected.
 
 \subsubsection{Exploration of groups}
-By default, the command \verb|\noexploregroups| is called, so in the main argument, \Xstring does not look into groups, and simply consider them as \US.
+By default, the command \verb|\noexploregroups| is called, so in the argument containing the string of tokens, \Xstring does not look into groups, and simply consider them as a \US.
 
-For specific uses, it can be necessary to look into groups: \verb|\exploregroups| changes the exploration mode an makes the macros look inside groups.\medskip
+For specific uses, it can be necessary to look into groups: \verb|\exploregroups| changes the exploration mode and forces the macros to look inside groups.\medskip
 
-What does this exploration mode in the preceding example? \Xstring does not count the group as a single \US but look inside it and counts the \US found inside (\verb|x|, \verb|y| and \verb|z|), and so on if there were several nested groups:\smallskip
+What does this exploration mode in the previous example? \Xstring does not count the group as a single \US but looks inside it and counts the \US found inside (\verb|x|, \verb|y| and \verb|z|), and so on if there were several nested groups:\smallskip
 
 \begin{minipage}[r]{0.6\linewidth}
 \hfill
@@ -844,7 +867,7 @@ What does this exploration mode in the preceding example? \Xstring does not coun
 \fullexpandarg\noexploregroups
 \medskip
 
-Exploring the groups can be usefull for counting a substring in a string (\verb|\StrCount|), for the position of a substring in a string (\verb|\StrPosition|) or for tests, but has a severe limitation with macros returning a string: when an argument is cut inside a group, \textbf{the result does not take into account what is outside this group}. This exploration mode must be used knowingly this limitation when calling macros returning a string.\smallskip
+Exploring the groups can be usefull for counting a substring in a string (\verb|\StrCount|), for the position of a substring in a string (\verb|\StrPosition|) or for tests, but has a severe limitation with macros returning a string: when a string is cut inside a group, \textbf{the result does not take into account what is outside this group}. This exploration mode must be used knowingly this limitation when calling macros returning a string.\smallskip
 
 Let's see what this means with an example. We want to know what is on the left of the second appearance of \verb|\a| in the argument \verb|\a1{\b1\a2}\a3|. As groups are explored, this appearance is inside this group : \verb|{\b1\a2}|. The result will be \verb|\b1|. Let's check:\smallskip
 
@@ -871,19 +894,17 @@ Exploring the groups\footnote{The file test of \Xstring has many examples underl
 
 Moreover, 2 macros run in \verb|\noexploregroups| mode, whatever be the current mode: \verb|\StrBetween| et \verb|\StrMid|.\medskip
 
-It is possible to save the "explore mode" with \verb|\saveexploremode|, then modify this "explore mode" and come back to the situation when it was saved with \verb|\restoreexploremode|.
+It is possible to save the exploration mode with \verb|\saveexploremode|, then modify it and come back to the situation when it was saved with \verb|\restoreexploremode|.
 
-\subsection{Catcode of arguments, starred macros}
+\subsection{Catcode and starred macros}
 \label{macrosetoilees}
-Macros of this package take the catcodes of characters into account. To avoid unexpected behaviour (particulary with tests), you should keep in mind that characters \emph{and their catcodes} are examined.\medskip
+Macros of this package take the catcodes of tokens into account. To avoid unexpected behaviour (particulary with tests), you should keep in mind that tokens \emph{and their catcodes} are examined.\medskip
 
 For instance, these two arguments:\par\medskip
 \hfil\verb|{\string a\string b}|\qquad and\qquad\verb|{ab}|\hfil{}\par\smallskip
-do \emph{not} expand into equal strings for xstring! Because of the command \verb|\string|, the first expands into "\verb|ab|" with catcodes 12 while the second have characters with their natural catcodes 11. Catcodes do not match! It is necessary to be aware of this, particulary with \TeX{} commands like \verb|\string| whose expansions are a strings with char catcodes 12 and 10 : \verb|\detokenize|, \verb|\meaning|, \verb|\jobname|, \verb|\fontname|, \verb|\romannumeral|, etc.\medskip
+do \emph{not} expand into equal strings for xstring! Because of the command \verb|\string|, the first expands into "\verb|ab|" with catcodes 12 while the second have characters with their natural catcodes 11. Catcodes do not match! It is necessary to be aware of this, particulary with \TeX{} commands like \verb|\string| whose expansions are a strings with chars catcodes 12 and 10 : \verb|\detokenize|, \verb|\meaning|, \verb|\jobname|, \verb|\fontname|, \verb|\romannumeral|, etc.\medskip
 
-Starred macros do not take catcodes into account. They simply convert their textual arguments into arguments with catcodes 10, 11 and 12, and call the non-starred macros with these modified arguments.\medskip
-
-\textbf{Warning}: the use of a strarred macro has consequences! The arguments are \guill{detokenized}, thus, there is no more control sequences, groups, neither any special char: everything is converted into chars with "harmless" catcodes.\medskip
+Starred macros do not take catcodes into account. They simply convert some arguments into arguments with catcodes 10, 11 and 12, and call the non-starred macros with these modified arguments. The optional arguments are not modified and the catcodes are left unchanged.\medskip
 
 Here is an example:\par\smallskip
 \begin{minipage}[r]{0.6\linewidth}
@@ -899,26 +920,228 @@ Here is an example:\par\smallskip
 	\IfStrEq*{\string a\string b}{ab}{true}{false}
 \end{minipage}\smallskip
 
-In the example above, after expansion (assumed that  \verb|\fullexpandarg| is active), the first argument contains \verb|{ab}| where, because of \verb|\string|, both chars have catcode 12. The second argument is \verb|{ab}| where both chars have their natural catcode 11. Strings are not equal because of the catcode and the test is negative, if the unstarred version is used.\bigskip
+The strings do not match because of catcode differences: the test is negative in the non-starred macro.\bigskip
 
-For the macros returning a string, if the starred version is used, the result will be a string in which chars have catcodes 12 and 10 for space. For example, after a "\verb|\StrBefore*{a \b c d}{c}[\mytext]|", the control sequence \verb|\mytext| expands to "\verb|a|${}_{12}$\verb*| |${}_{10}$\verb|\|${}_{12}$\verb|b|${}_{12}$\verb*| |${}_{10}$".
+\textbf{Warning}: the use of a strarred macro has consequences! The arguments are \guill{detokenized}, thus, there is no more control sequences, groups, neither any special char: everything is converted into chars with "harmless" catcodes.\medskip
+
+For the macros returning a string, if the starred version is used, the result will be a string in which chars have catcodes 12 and 10 for space. For example, after a "\verb|\StrBefore*{a \b c d}{c}[\mytext]|", the control sequence \verb|\mytext| expands to "\verb|a|${}_{12}$\verb*| |${}_{10}$\verb|\|${}_{12}$\verb|b|${}_{12}$\verb*| |${}_{10}$".\medskip
+
+The macro with a starred version are listed below. For these macros, if starred version is used, the \textcolor{red}{red} arguments will be detokenized:\smallskip
 
-\section{Other macros for assistance in programming}
+\parindent3em
+\begin{itemize}
+	\item\verb|\IfSubStr|\etoile\arguC{number}{\colorise\ARGU{string}\ARGU{stringA}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfSubStrBefore|\etoile\arguCC{number1}{number2}{\colorise\ARGU{string}\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfSubStrBehind|\etoile\arguCC{number1}{number2}{\colorise\ARGU{string}\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfBeginWith|\etoile{\colorise\ARGU{string}\ARGU{stringA}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfEndWith|\etoile{\colorise\ARGU{string}\ARGU{stringA}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfStrEq|\etoile{\colorise\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfEq|\etoile{\colorise\ARGU{stringA}\ARGU{stringB}}\ARGU{true}\ARGU{false}
+	\item\verb|\IfStrEqCase|\etoile{\colorise\ARGU{string}\texttt{\color{black}\{}\colorise\ARGU{string1}}\ARGU{code1}\par
+		\setbox0=\hbox{{\ttfamily\string\IfStrEqCase}\etoile\ARGU{string}{\ttfamily\{}}
+		\hskip\wd0{\colorise\ARGU{string2}}\ARGU{code2}\par
+		\hskip\wd0\ \ldots\par
+		\hskip\wd0{\colorise\ARGU{string $n$}}\ARGU{code $n$}\verb|}|\arguC{other cases code}
+	\item\verb|\IfEqCase|\etoile{\colorise\ARGU{string}\texttt{\color{black}\{}\colorise\ARGU{string1}}\ARGU{code1}\par
+		\setbox0=\hbox{{\ttfamily\string\IfEqCase}\etoile\ARGU{string}{\ttfamily\{}}
+		\hskip\wd0{\colorise\ARGU{string2}}\ARGU{code2}\par
+		\hskip\wd0\ \ldots\par
+		\hskip\wd0{\colorise\ARGU{string $n$}}\ARGU{code $n$}\verb|}|\arguC{other cases code}
+	\item\verb|\StrBefore|\etoile\arguC{number}{\colorise\ARGU{string}\ARGU{stringA}}\arguC{name}
+	\item\verb|\StrBehind|\etoile\arguC{number}{\colorise\ARGU{string}\ARGU{stringA}}\arguC{name}
+	\item\verb|\StrBetween|\etoile\arguCC{number1}{number2}{\colorise\ARGU{string}\ARGU{stringA}\ARGU{stringB}}\arguC{name}
+	\item\verb|\StrCompare|\etoile{\colorise\ARGU{stringA}\ARGU{stringB}}\arguC{name}
+\end{itemize}
+\parindent0pt
+
+\section{Advanced macros for programming}
 Though \Xstring is able to read arguments containing \TeX{} or \LaTeX{} code, for some advanced programming needs, it can be insufficient. This chapter presents other macros able to get round some limitations.
 
+\subsection{Finding a group, macros {\ttfamily\textbackslash StrFindGroup} and {\ttfamily\textbackslash groupID}}
+When \verb=\exploregroups= mode is active, the macro \verb=\StrFindGroup= finds a group between braces with its identifier:\smallskip
+
+\verb|\StrFindGroup|\ARGU{argument}\ARGU{identifier}\arguC{name}\medskip
+
+When the group matching the identifier does not exist, an empty string is assigned to \argu{name}. If the group is found, this group \emph{with its braces} is assigned to \argu{name}.\smallskip
+
+This identifier characterizes the nestling position of the group. It is a list of one or several integers separated with commas. $n_1$, the first integer is the number of the group (not nestled in another) in which the sought group is. Inside this group, the second integer $n_2$ is the number of the group (not nestled in another) in which the sought group is\ldots and so on until the necessary nestling depth is reached to obtain the sougth after group.\bigskip
+
+Let's take an example with 3 levels of nestled groups. In this example, braces delimiting groups are colored in red for nestling level 1, in blue for level 2 and in green for level 3. The groups are numbered with the rule seen above:
+\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
+In this example:\parindent3em
+\begin{itemize}
+	\item the group \verb={{bc}d{efg}}= has the identifier: \texttt{\color{red}1}
+	\item the group \verb={ij}= has the identifier: \texttt{{\color{red}2},\color{blue}1}
+	\item the group \verb={no}= has the identifier: \texttt{{\color{red}2},{\color{blue}3},\color{green}2}
+	\item the whole argument \verb=a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}= has the identifier \verb=0=, only case where the integer 0 is appears in the identifier of a group.
+\end{itemize}
+\parindent0pt
+\medskip
+Here is the full example:\smallskip
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\exploregroups
+	\expandarg
+	\def\string{a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}}
+	\StrFindGroup{\string}{1}[\mygroup]
+	\meaning\mygroup\par
+	\StrFindGroup{\string}{2,1}[\mygroup]
+	\meaning\mygroup\par
+	\StrFindGroup{\string}{2,3,2}[\mygroup]
+	\meaning\mygroup\par
+	\StrFindGroup{\string}{2,5}[\mygroup]
+	\meaning\mygroup\par
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\exploregroups
+	\expandarg
+	\def\string{a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}}
+	\StrFindGroup{\string}{1}[\mygroup]
+	\meaning\mygroup\par
+	\StrFindGroup{\string}{2,1}[\mygroup]
+	\meaning\mygroup\par
+	\StrFindGroup{\string}{2,3,2}[\mygroup]
+	\meaning\mygroup\par
+	\StrFindGroup{\string}{2,5}[\mygroup]
+	\meaning\mygroup\par
+\end{minipage}
+\bigskip
+
+The reverse process exists, and several macros of \Xstring provide the identifier of the group in which they made a cut or they found a substring. These macros are: \verb|\IfSubStr|, \verb|\StrBefore|, \verb|\StrBehind|, \verb|\StrSplit|, \verb|\StrLeft|, \verb|\StrGobbleLeft|, \verb|\StrRight|, \verb|\StrGobbleRight|, \verb|\StrChar|, \verb|\StrPosition|.\medskip
+
+After these macros, the control sequence \verb|\groupID| expands to the identifier of the group where the cut has been done or the search has succeeded. When not cut can be done or the search fails, \verb|\groupID| is empty. Obvioulsly, the use of \verb|\groupID| has sense only when \verb|\exploregroups| mode is acive and when non starred macros are used.\smallskip
+
+Here are some examples with the macro \verb|\StrChar|:\smallskip
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\exploregroups
+	char no 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
+	\string\groupID = \groupID\par
+	char no 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
+	\string\groupID = \groupID\par
+	char no 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
+	\string\groupID = \groupID\par
+	char no 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
+	\string\groupID = \groupID
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\exploregroups
+	char no 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
+	\string\groupID = \groupID\par
+	char no 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
+	\string\groupID = \groupID\par
+	char no 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
+	\string\groupID = \groupID\par
+	char no 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
+	\string\groupID = \groupID
+\end{minipage}
+
+\subsection{Splitting a string, the macro {\ttfamily\textbackslash StrSplit}}
+\label{StrSplit}
+Here is the syntax:\smallskip
+
+\verb|\StrSplit|\ARGU{string}\ARGU{number}\ARGU{stringA}\ARGU{stringB}
+\smallskip
+
+The \argu{string}, is splitted after the \US at position \argu{number}. The left part is assigned to the control sequence \argu{stringA} and the right part is assigned to \argu{stringB}.\par
+This macro returns two strings, so it does \emph{not} display anything. Consequently, it does not provide the optional argument in last position.\medskip
+
+\begin{Conditions}
+	\item If \argu{number}${}\leqslant0$, \argu{stringA} is empty and \argu{stringB} is equal to \argu{string};
+	\item If \argu{number}${}\geqslant$\argu{lengthString}, \argu{stringA} is equal to \argu{string} and \argu{stringB} is empty;
+	\item If \argu{string} is empty, \argu{stringA} and \argu{stringB} are empty, whatever be the integer \argu{number}.
+\end{Conditions}
+
+\setverbdelim{=}
+\exemple=\StrSplit{abcdef}{4}{\aa}{\bb}results: |\aa| and |\bb|=
+\exemple=\StrSplit{a b c }{2}{\aa}{\bb}results: |\aa| and |\bb|=
+\exemple=\StrSplit{abcdef}{1}{\aa}{\bb}results: |\aa| and |\bb|=
+\exemple=\StrSplit{abcdef}{5}{\aa}{\bb}results: |\aa| and |\bb|=
+\exemple=\StrSplit{abcdef}{9}{\aa}{\bb}results: |\aa| and |\bb|=
+\exemple=\StrSplit{abcdef}{-3}{\aa}{\bb}results: |\aa| and |\bb|=
+\setverbdelim{|}\medskip
+
+When the exploration of groups is active and the cut is made at the end of a group, the content of the left string will tbe the entire group while the right string will be empty. The example shows this:\smallskip
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\exploregroups
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\exploregroups
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB
+\end{minipage}
+\medskip
+
+This macro provides a star version: in this case, the cut is made just before the \US which follows the \US at position \argu{number}. Both version give same results, except when the cut is made at the end of a group; in that case, \verb|\StrSplit| closes as many group as necessary until it finds the next \US: the cut is made just before this \US.\smallskip
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\exploregroups
+	With natural macro:\par
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID = \groupID\par
+	With star macro:\par
+	\StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID\ = \groupID
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\exploregroups
+	With natural macro:\par
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID = \groupID\par
+	With star macro:\par
+	\StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID\ = \groupID
+\end{minipage}
+
 \subsection{Assign a verb content, the macro \ttfamily\textbackslash verbtocs}
 \label{verbtocs}
-The macro \verb|\verbtocs| allow to read the content of a \guill{verb} argument containing special characters: \verb|&|, \verb|~|, \verb|\|, \verb|{|, \verb|}|, \verb|_|, \verb|#|, \verb|$|, \verb|^| et \verb|%|. The catcodes of \guill{normal} characters are left unchanged while special characters take a catcode 12. Then, these characters are assigned to a control sequence. The syntax is:\medskip
+The macro \verb|\verbtocs| allow to read the content of a \guill{verb} argument containing special characters: \verb|&|, \verb|~|, \verb|\|, \verb|{|, \verb|}|, \verb|_|, \verb|#|, \verb|$|, \verb|^| and \verb|%|. The catcodes of \guill{normal} characters are left unchanged while special characters take a catcode 12. Then, these characters are assigned to a control sequence. The syntax is:\medskip
 
 \hfill\verb|\verbtocs|\ARGU{name}|\argu{characters}|\hfill{}
 \smallskip
 
-\argu{name} is the name of the control sequence receiving, with an \verb|\edef|, the \argu{characters}. \argu{name} thus contains char with catcodes 12 or 10 for space.\medskip
+\argu{name} is the name of the control sequence receiving, with an \verb|\edef|, the \argu{characters}. \argu{name} thus contains tokens with catcodes 12 (or 10 for space).\medskip
 
-By default, the character delimiting the verb content is \guill{|}. Obviously, this character cannot be both delimiting and being contained into what it delimits. If you need to verbatimize strings containing \guill{|}, you can change at any time the character delimiting the verb content with the macro:\par\medskip
+By default, the token delimiting the verb content is \guill{|}. Obviously, this token cannot be both delimiting and being contained into what it delimits. If you need to verbatimize strings containing \guill{|}, you can change at any time the token delimiting the verb content with the macro:\par\medskip
 \hfill\verb|\setverbdelim|\ARGU{character}\hfill{}\smallskip
 
-Any \argu{character} with a catcode 11 or 12 can be used\footnote{Several characters can be used, but the syntax of \texttt{\textbackslash verbtocs} becomes less readable ! For this reason, a warning occurs when the argument of \texttt{\textbackslash setverbdelim} contains more than a single character.}. For example, after \verb|\setverbdelim{=}|, a verb argument look like this: \verb|=|\argu{characters}\verb|=|.\medskip
+Any \argu{token} can be used\footnote{Several tokens can be used, but the syntax of \texttt{\textbackslash verbtocs} becomes less readable ! For this reason, a warning occurs when the argument of \texttt{\textbackslash setverbdelim} contains more than a single token.}. For example, after \verb|\setverbdelim{=}|, a verb argument look like this: \verb|=|\argu{characters}\verb|=|.\medskip
 
 About verb arguments, keep in mind that:
 \begin{itemize}
@@ -1098,12 +1321,13 @@ In the following teaching example\footnote{It is possible to make much more simp
 
 \subsection{The macro \ttfamily\textbackslash StrRemoveBraces}
 Advanced users may need to remove the braces of an argument.
+
 The macro \verb|\StrRemoveBraces| does this. Its syntax is:\smallskip
 
-\verb|\StrRemoveBraces|\ARGU{stringe}\arguC{name}
+\verb|\StrRemoveBraces|\ARGU{string}\arguC{name}
 \smallskip
 
-This macro is sensitive to exploration mode and will remove \emph{all} the braces with \verb|\exploregroups| while it will remove braces of higher level with \verb|\noexploregroups|.\medskip
+This macro is sensitive to exploration mode and will remove \emph{all} the braces with \verb|\exploregroups| while it will remove braces of lower level with \verb|\noexploregroups|.\medskip
 
 \exemple|\noexploregroups|
 \exemple|\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]|
@@ -1111,7 +1335,7 @@ This macro is sensitive to exploration mode and will remove \emph{all} the brace
 \exemple|\exploregroups|
 \exemple|\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]|
 \exemple|\meaning\mycs|
-
+\noexploregroups
 \subsection{Examples}
 \label{exemples}
 Here are some very simple examples involving the macros of this package in programming purposes.
@@ -1150,8 +1374,66 @@ With this code, in both arguments, the first token \verb|\empty| is expanded to
 
 By this way, \verb|\empty| is a way to "hack" \verb|\expandarg|: it allows to avoid the expansion of all the other tokens. The control sequence \verb|\noexpand| can be used instead of \verb|\empty| for the same result.
 
-\subsubsection{Example 2}
-Let's try to write a macro \verb|\tofrac| that transforms an argument of this type \guill{a/b} into \guill{$\frac{a}{b}$}:\par\medskip
+\subsubsection{Exemple 2}
+Here, we try to write a macro which gobbles \verb|n| \USs in a string from a given position, and assigns the result to a control sequence.
+
+Let's call this macro \verb|StringDel| and let's give it this syntax:
+
+\hfil\verb|\StringDel{string}{position}{n}{\name_of_result}|\hfil{}
+\medskip
+
+We can proceed like this: take the string before the position and save it. Then remove \verb|n + position| \USs from the initial string, and add (concatenate) this result to the string previously saved. This gives the following code:\medskip
+
+\begin{minipage}[r]{0.7\linewidth}
+	\hfill
+	\begin{boxedverbatim}
+		\newcommand\StringDel[4]{%
+			\begingroup
+			\expandarg% local inside this group
+			\StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
+			\StrGobbleLeft{\empty#1}{\number\numexpr#2+#3-1}[\StrA]%
+			\expandafter\expandafter\expandafter\endgroup
+			\expandafter\expandafter\expandafter\def
+			\expandafter\expandafter\expandafter#4%
+			\expandafter\expandafter\expandafter{\expandafter#4\StrA}%
+			}
+
+		\noexploregroups
+		\StringDel{abcdefgh}{2}{3}{\cmd}
+		\meaning\cmd
+
+		\StringDel{a\textbf{1}b\textbf{2c}3d}{3}{4}{\cmd}
+		\meaning\cmd
+	\end{boxedverbatim}
+ \hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\newcommand\StringDel[4]{%
+		\begingroup
+		\expandarg% local inside this group
+		\StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
+		\StrGobbleLeft{\empty#1}{\number\numexpr#2+#3-1}[\StrA]%
+		\expandafter\expandafter\expandafter\endgroup
+		\expandafter\expandafter\expandafter\def
+		\expandafter\expandafter\expandafter#4%
+		\expandafter\expandafter\expandafter{\expandafter#4\StrA}%
+		}
+
+	\noexploregroups
+	\StringDel{abcdefgh}{2}{3}{\cmd}
+	\meaning\cmd
+
+	\StringDel{a\textbf{1}b\textbf{2c}3d}{3}{4}{\cmd}
+	\meaning\cmd
+\end{minipage}\fullexpandarg
+\bigskip
+
+To concatenate, the \LaTeX{} macro \verb|\g@addto@macro| could have been used, leading to a lighter code without the huge bridge of \verb|\expandafter|. The assignment\footnote{The macro {\ttfamily\string\g@addto@macro} can be used if the catcode of "{\ttfamily\string@}" is temporarily changed with {\ttfamily\string\makeatletter} and restored with {\ttfamily\string\makeatother}} can be written like this:\smallskip
+
+\hfil\verb|\expandafter\g@addto@macro\expandafter#4\expandafter{\StrA}\endgroup|\hfil{}
+
+\subsubsection{Example 3}
+Let's try to write a macro \verb|\tofrac| that transforms an argument of this type \guill{a/b} into \guill{$\frac{a}{b}$}.\par\medskip
 
 First of all, let's cancel the expansion of arguments with \verb|\noexpandarg|, we do not need expansion here. Then, it's easy to cut what is before and behind the first occurrence of \guill{/} (assumed there is a single occurrence) and assign it to \verb|\num| and \verb|\den| and simply call the macro \verb|\frac| :\medskip
 
@@ -1183,7 +1465,7 @@ First of all, let's cancel the expansion of arguments with \verb|\noexpandarg|,
 	\tofrac{x+\sqrt{x}/\sqrt{x^2+x+1}}
 \end{minipage}\fullexpandarg
 
-\subsubsection{Example 3}
+\subsubsection{Example 4}
 Let's try to write a macro \verb|\boldafter| which writes in bold the first word that follows the word contained in the expansion of \verb|\word|.\medskip
 
 \begin{minipage}[r]{0.6\linewidth}
@@ -1221,7 +1503,7 @@ Let's try to write a macro \verb|\boldafter| which writes in bold the first word
 	\boldafter{The xstring package is new}{is}
 \end{minipage}\fullexpandarg
 
-\subsubsection{Example 4}
+\subsubsection{Example 5}
 A control sequence \verb|\myCS| défined with an \verb|\def| contains control sequences with their possible arguments. How to reverse the order of the 2 first control sequences? For this, a macro \verb|\swaptwofirst| does the job and displays the result. But this time, it is not possible to seek the token \verb|\| (catcode 0) with the macros of \Xstring. This is why the use of \verb|\scancs| is necessary: after the detokenization of the argument, it becomes possible to search the char \verb|\| (catcode 12). After 4 lines, the process made by the macros of \Xstring (\verb|\StrBefore| and \verb|\StrBehind|) is finish, a retokenization is done by \verb|\tokenize| and \verb|\before| and \verb|\after| are swapped at this moment.\medskip
 
 \begin{minipage}[r]{0.6\linewidth}
@@ -1261,102 +1543,41 @@ A control sequence \verb|\myCS| défined with an \verb|\def| contains control se
 	\swaptwofirst{\Large\underline{A}\textbf{B}123}
 \end{minipage}
 
-\subsubsection{Example 5}
-A control sequence \verb|\myCS| defined with an \verb|\edef| contains control sequences and "groups" between braces. Let's try to find the $n$\th group, i.e. what is between the $n$\th pair of balanced braces. In this example, \verb|\myCS| contains:\par\medskip
-\hfill\verb|\a{1\b{2}}\c{3}\d{4\e{5}\f{6{7}}}|\hfill{}\medskip
+\subsubsection{Example 6}
+In a string, we want to find the $n$\th{} word between 2 given delimiters. For this, let's write a macro \verb|\findword| with an optional argument which content is the delimiter (space by default), 1 argument containing the string and an other argument containing the number $n$.\medskip
+
+The macro \verb|\findword| artfully uses \verb|\StrBetween| and \verb|\numexpr|:\medskip
 
 \begin{minipage}[r]{0.6\linewidth}
 	\hfill
 	\begin{boxedverbatim}
-		\fullexpandarg
-		\newcount\occurr
-		\newcount\nbgroup
-		\newcommand\findgroup[2]{%
-		  \scancs[1]{\text}{#2}%
-		  \occurr=0
-		  \nbgroup=0
-		  \def\findthegroup{%
-		    \StrBehind{\text}{\Obr}[\remain]%
-		    \advance\occurr by 1% next "{"
-		    \StrBefore[\the\occurr]{\remain}{\Cbr}[\group]%
-		    \StrCount{\group}{\Obr}[\nbA]%
-		    \StrCount{\group}{\Cbr}[\nbB]%
-		    \ifnum\nbA=\nbB% balanced braces ?
-		      \advance\nbgroup by 1
-		      \ifnum\nbgroup<#1% not the good group ?
-		        \StrBehind{\text}{\group}[\text]%
-		        \occurr=0% initialise \text & \occur
-		        \expandafter\expandafter\expandafter
-		        \findthegroup% do it again
-		      \fi
-		    \else% unbalanced braces ?
-		      % look for next "}"
-		      \expandafter
-		      \findthegroup
-		    \fi}
-		  \findthegroup
-		  \group}
-
-		\verbtocs{\Obr}|{|
-		\verbtocs{\Cbr}|}|
-		\def\myCS{\a{1\b{2}}\c{3}\d{4\e{5}\f{6{7}}}}
-
-		group 1: \findgroup{1}{\myCS}\par
-		group 2: \findgroup{2}{\myCS}\par
-		group 3: \findgroup{3}{\myCS}
+	\newcommand\findword[3][ ]{%
+		\StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}}
+	\noexpandarg
+	|\findword{a bc d\textit{e f} gh}{3}|
+
+	|\findword[\@nil]{1 \@nil 2 3 \@nil4\@nil5}{2}|
 	\end{boxedverbatim}
 	\hspace*{0.3cm}
 \end{minipage}%
 \begin{minipage}[r]{0.3\linewidth}
-	\fullexpandarg
-	\newcount\occurr
-	\newcount\nbgroup
-	\newcommand\findgroup[2]{%
-		\scancs[1]{\text}{#2}%
-		\occurr=0
-		\nbgroup=0
-		\def\findthegroup{%
-		\StrBehind{\text}{\Obr}[\remain]%
-		\advance\occurr by 1% next "{"
-		\StrBefore[\the\occurr]{\remain}{\Cbr}[\group]%
-		\StrCount{\group}{\Obr}[\nbA]%
-		\StrCount{\group}{\Cbr}[\nbB]%
-		\ifnum\nbA=\nbB% balanced braces ?
-			\advance\nbgroup by 1
-			\ifnum\nbgroup<#1% not the good group ?
-				\StrBehind{\text}{\group}[\text]%
-				\occurr=0% initialise \text & \occur
-				\expandafter\expandafter\expandafter
-				\findthegroup\expandafter% do it again
-			\fi
-		\else% unbalanced braces ?
-			% look for next "}"
-			\expandafter
-			\findthegroup
-		\fi}
-		\findthegroup
-		\group}
-
-	\verbtocs{\Obr}|{|
-	\verbtocs{\Cbr}|}|
-	\def\myCS{\a{1\b{2}}\c{3}\d{4\e{5}\f{6{7}}}}
-
-	group 1: \findgroup{1}{\myCS}\par
-	group 2: \findgroup{2}{\myCS}\par
-	group 3: \findgroup{3}{\myCS}
-\end{minipage}
-\medskip
+	\newcommand\findword[3][ ]{%
+		\StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}}
+	\noexpandarg
+	|\findword{a bc d\textit{e f} gh}{3}|
 
-Notice that 2 counters, 2 tests and a double recursion are necessary to find the group: one of each to find which "\verb|}|" delimits the end of the current group, and the others to calculate the number of the group being read.\bigskip\bigskip
+	|\findword[\@nil]{1 \@nil 2 3 \@nil4\@nil5}{2}|
+\end{minipage}
 
+\bigskip\bigskip
 \begin{center}
 $\star$\par
 $\star$\quad$\star$
 \end{center}
 \bigskip\bigskip
 
-That's all, I hope you will find this package useful !\par
-Please, send me an email if you find a bug or if you have any idea of improvement\ldots\medskip
+That's all, I hope you will find this package useful!\par
+Please, send me an \href{mailto:unbonpetit@gmail.com}{email} if you find a bug or if you have any idea of improvement\ldots\medskip
 
 Christian Tellechea
 \end{document}
\ No newline at end of file
diff --git a/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.pdf b/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.pdf
index f8cd7c7c233..c0e0ed96678 100644
--- a/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.pdf
+++ b/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.pdf
diff --git a/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.tex b/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.tex
index 0cbf4bd637d..295644470ec 100644
--- a/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.tex
+++ b/Master/texmf-dist/doc/generic/xstring/xstring_doc_fr.tex
@@ -1,7 +1,7 @@
 % Ceci est xtring_doc_fr.tex, le manuel en français de xstring
 % This is xtring_doc_fr.tex, the french manual of xstring
 %
-% Christian Tellechea 2008
+% Christian Tellechea 2009
 %
 % email : unbonpetit@gmail.com
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -18,21 +18,32 @@
 \documentclass[a4paper,10pt]{article}
 \usepackage[utf8]{inputenc}
 \usepackage[T1]{fontenc}
-\usepackage[dvips,colorlinks=true,hyperfootnotes=false,citecolor=black,filecolor=black,linkcolor=blue,urlcolor=blue,bookmarks=false,pdfauthor={Christian TELLECHEA},pdftitle={xstring},pdfsubject={package pour la manipulation de chaines de caractères},pdfkeywords={xstring,latex,string,chaine de caractères},pdfcreator={LaTeX}]{hyperref}
-\usepackage[a4paper,dvips,margin=2cm]{geometry}
-\usepackage{amssymb}
-\usepackage{textcomp}
+\usepackage[dvips,colorlinks=true,hyperfootnotes=false,citecolor=black,filecolor=black,linkcolor=blue,urlcolor=blue,bookmarks=false,pdfauthor={Christian TELLECHEA},pdftitle={xstring},pdfsubject={package pour la manipulation de chaines de lexèmes},pdfkeywords={xstring,latex,string,chaine},pdfcreator={LaTeX}]{hyperref}
+\usepackage[a4paper,dvips,margin=1.9cm]{geometry}
+\usepackage{amsmath,amssymb,amsfonts,textcomp}
+\usepackage{color}
 \usepackage{moreverb}
 \usepackage{lmodern}
 \usepackage{eurosym}
 \usepackage{xspace}
 \usepackage{xstring}
 \usepackage[frenchb]{babel}
-
 \makeatletter
-%\@addtoreset{footnote}{page}% reset du n° de footnote à chaque page
-\newcommand*\exemple{\@ifstar{\def\frontiere{|}\@xs@MakeVerb}{\def\frontiere{}\@xs@MakeVerb}}
-\long\def\@xs@afterreadverb#1{%
+% redéfinition de l'écriture des textes des footnote
+\long\def\@makefntextFB#1{%
+	\ifx\thefootnote\ftnISsymbol
+		\@makefntextORI{#1}%
+	\else
+		\rule\z@\footnotesep
+		\setbox\@tempboxa\hbox{\@thefnmark}%
+			\ifdim\wd\@tempboxa>\z@
+				\kern2em\llap{\@thefnmark.\kern0.5em}%
+			\fi
+		\begingroup\advance\hsize-2em\vtop{#1}\endgroup%
+	\fi}
+
+\newcommand*\exemple{\@ifstar{\let\frontiere\textbar\@xs@MakeVerb}{\let\frontiere\@empty\@xs@MakeVerb}}
+\def\@xs@afterreadverb#1{%
 	\normalexpandarg
 	\tokenize\cs@resultat{#1}%
 	\fullexpandarg
@@ -40,12 +51,10 @@
 \makeatother
 \newcommand\guill[1]{\og{}#1\fg{}}
 \newcommand\argu[1]{$\langle$\textit{#1}$\rangle$}
-\newcommand\ARGU[1]{\texttt{\{}\argu{#1}\texttt{\}}}
-\newcommand\arguC[1]{\texttt{[}\argu{#1}\texttt{]}}
-\newcommand\arguCC[2]{\texttt{[}\argu{#1}{,}\argu{#2}\texttt{]}}
-\newcommand\texte[1]{\texttt{texte}${}_{#1}$}
+\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\etoile{$\langle$\texttt{[*]}$\rangle$}
-\newcommand\voirdeftexte{~(voir \ref{deftexte})}
 \newenvironment{Conditions}[1][1cm]%
 {\begin{list}%
 	{$\vartriangleright$}%
@@ -83,7 +92,7 @@
 		\begin{minipage}{0.85\linewidth}
 			\noindent
 			\hfill\textbf{\textit{Résumé}}\hfill{}\medskip\par
-			Cette extension, qui requiert Plain $\varepsilon$-\TeX, regroupe un ensemble de macros manipulant des chaînes pouvant contenir des caractères, séquences de contrôle, groupes entre accolades, de façon à utiliser les macros aussi pour de la programmation \TeX{} :
+			Cette extension, qui requiert Plain $\varepsilon$-\TeX, regroupe un ensemble de macros manipulant des chaînes de lexèmes (tokens en anglais). Les macros 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 lexèmes, c'est-à-dire du code \TeX{}. Parmis les fonctionnalités, les principales sont :
 			\setlength{\parindent}{1.5em}
 			\begin{itemize}
 				\item[$\triangleright$] des tests :
@@ -93,11 +102,12 @@
 						\item une chaîne représente t-elle un entier relatif ? Un nombre décimal ?
 						\item deux chaînes sont-elles égales ?
 					\end{itemize}
-				\item[$\triangleright$] des extractions de chaînes :
+				\item[$\triangleright$] des recherches de chaînes :
 					\begin{itemize}
-						\item renvoi de ce qui se trouve avant (ou après) la $n$\ieme{} occurrence d'une sous-chaîne;
-						\item renvoi de ce qui se trouve entre les occurrences de 2 sous-chaînes;
-						\item sous-chaîne comprise entre 2 positions, etc.
+						\item recherche de ce qui se trouve avant (ou après) la $n$\ieme{} occurrence d'une sous-chaîne;
+						\item recherche de ce qui se trouve entre les occurrences de 2 sous-chaînes;
+						\item sous-chaîne comprise entre 2 positions;
+						\item recherche d'un groupe entre accolades par son identifiant.
 					\end{itemize}
 				\item[$\triangleright$] le remplacement de toutes ou des $n$ premières occurrences d'une sous-chaîne par une autre sous-chaîne;
 				\item[$\triangleright$] des calculs de nombres :
@@ -105,32 +115,32 @@
 						\item longueur d'une chaîne;
 						\item position de la la $n$\ieme{} occurrence d'une sous-chaîne;
 						\item comptage du nombre d'occurrences d'une sous-chaîne dans une autre;
-						\item position du 1\ier{} caractère différent entre 2 chaînes.
+						\item position de la 1\iere{} différence entre 2 chaînes;
+						\item renvoi de l'identifiant du groupe dans lequel une recherche ou une coupure s'est faite.
 					\end{itemize}
 			\end{itemize}
 			\setlength{\parindent}{0pt}
 			\medskip
-			D'autres commandes permettent de gérer les caractères spéciaux normalement interdits dans les chaînes (\verb|#| et \verb|%|), ainsi que d'éventuelles différences entre catcodes de caractères, ce qui devrait permettre de couvrir tous les besoins en matière de programmation.
+			D'autres commandes permettent de gérer les lexèmes spéciaux normalement interdits dans les chaînes (\verb|#| et \verb|%|), ainsi que d'éventuelles différences entre catcodes de lexèmes, ce qui devrait permettre de couvrir tous les besoins en matière de programmation.
 		\end{minipage}
 	\end{center}
 	\hrulefill\vfill{}
 \end{titlepage}
-\pagebreak
+
 \tableofcontents
-\pagebreak
 
 \section{Présentation}
 \subsection{Description}
-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 opérant sur des chaînes de caractères représentant du code \TeX, un peu comme en disposent des langages dit \guill{évolués}. On y trouve les opérations habituelles sur les chaînes de caractères, 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 ou de caractères, calculs de position d'une sous-chaîne, calculs du nombre d'occurrences, etc.\medskip
+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 opérant sur des chaînes de lexèmes, 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
 
-\Xstring lit les arguments qui lui sont transmis \emph{\US par \US\footnote{Sauf cas particulier, une \US est un caractère lu dans le code à 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 à les lire caractère par caractère lorsque ceux-ci contiennent des caractères \guill{normaux}, c'est-à-dire dont les catcodes sont 10, 11 et 12. On peut également utiliser \Xstring à des fins de programmation en utilisant des arguments contenant des séquences de contrôle et des caractères 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
+Les arguments contenant des chaînes de lexèmes sont lus par \Xstring \emph{\US par \US\footnote{Sauf cas particulier, une \US est un caractère lu dans le code à 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 à les lire caractère par caractère lorsque ceux-ci contiennent des lexèmes \guill{normaux}, c'est-à-dire dont les catcodes sont 10, 11 et 12. On peut également utiliser \Xstring à des fins de programmation en utilisant des arguments contenant des séquences de contrôle et des lexèmes 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://www.ctan.org/tex-archive/macros/latex/contrib/substr/}{\nolinkurl{substr}} et \href{http://www.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 à utiliser pour la programmation.\medskip
 
-Comme les macros manipulent des chaînes pouvant éventuellement contenir des caractères, il peut arriver aux utilisateurs avancés de rencontrer des problèmes de \guill{catcodes\footnote{Codes de catégories, en français.}} conduisant à des comportement inattendus. Ces effets indésirables peuvent être contrôlés. Consulter en particulier le chapitre sur les catcodes des arguments page~\pageref{macrosetoilees}.
+Comme les macros manipulent des chaînes de lexèmes, il peut arriver aux utilisateurs avancés de rencontrer des problèmes de \guill{catcodes\footnote{Codes de catégories, en français.}} conduisant à des comportement inattendus. Ces effets indésirables peuvent être contrôlés. Consulter en particulier le chapitre sur les catcodes des arguments page~\pageref{macrosetoilees}.
 
 \subsection{Motivation}
-J'ai été conduit à écrire ce type de macros car je n'ai jamais vraiment trouvé de d'outils sous \LaTeX{} adaptés à mes besoins concernant le traitement de chaînes de caractères. Alors, au fil des mois, et avec l'aide de contributeurs\footnote{Je remercie chaleureusement Manuel alias \guill{\nolinkurl{mpg}} pour son aide précieuse, sa compétence et sa disponibilité.} de \nolinkurl{fr.comp.text.tex}, j'ai écrit quelques macros qui me servaient ponctuellement ou régulièrement. Leur nombre s'étant accru, et celles-ci devenant un peu trop dispersées dans les répertoires de mon ordinateur, je les ai regroupées dans ce package.
+J'ai été conduit à écrire ce type de macros car je n'ai jamais vraiment trouvé de d'outils sous \LaTeX{} adaptés à mes besoins concernant le traitement de chaînes. Alors, au fil des mois, et avec l'aide de contributeurs\footnote{Je remercie chaleureusement Manuel alias \guill{\nolinkurl{mpg}} pour son aide précieuse, sa compétence et sa disponibilité.} de \nolinkurl{fr.comp.text.tex}, j'ai écrit quelques macros qui me servaient ponctuellement ou régulièrement. Leur nombre s'étant accru, et celles-ci devenant un peu trop dispersées dans les répertoires de mon ordinateur, je les ai regroupées dans ce package.
 
 Ainsi, le fait de donner corps à un ensemble cohérent de macros force à davantage de rigueur et induit naturellement de nécessaires améliorations, ce qui a pris la majeure partie du temps que j'ai consacré à ce package. Pour harmoniser le tout, mais à contre-c\oe{}ur, j'ai fini par choisir des noms de macros à consonances anglo-saxonnes.\medskip
 
@@ -138,7 +148,7 @@ Ensuite, et cela a été ma principale motivation puisque j'ai découvert \LaTeX
 
 \section{Les macros}
 \subsection{Présentation des 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 caractères spéciaux et encore moins de séquence de contrôle dans les arguments !\medskip
+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 lexèmes 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 :\smallskip
 
@@ -147,10 +157,11 @@ Dans ce chapitre, la totalité des macros est présentée selon ce plan :\smalls
 	\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 à la présence d'espaces dans le résultat, celui-ci sera délimité par des \guill{|}, étant entendu qu'une chaîne vide est représentée par \guill{||}.
+	\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 à 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 à 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}
@@ -256,7 +267,7 @@ Teste si \argu{chaine} se termine par \argu{chaineA}, et exécute \argu{vrai} da
 
 \subsubsection{\ttfamily\textbackslash IfInteger}
 
-\verb|\IfInteger|\etoile\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
+\verb|\IfInteger|\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
 \smallskip
 
 Teste si \argu{nombre} est un nombre entier relatif, et exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\smallskip
@@ -275,7 +286,7 @@ Si le test est faux pour cause de caractères non autorisés, la séquence de co
 
 \subsubsection{\ttfamily\textbackslash IfDecimal}
 \label{ifdecimal}
-\verb|\IfDecimal|\etoile\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
+\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.\smallskip
@@ -310,7 +321,7 @@ Si le test est faux pour cause de caractères non autorisés, la séquence de co
 \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-à-dire si elles contiennent successivement les mêmes caractères dans le même ordre. Exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\smallskip
+Teste si les chaînes \argu{chaineA} et \argu{chaineB} sont égales, c'est-à-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
 
 \exemple|\IfStrEq{a1b2c3}{a1b2c3}{vrai}{faux}|
 \exemple|\IfStrEq{abcdef}{abcd}{vrai}{faux}|
@@ -331,8 +342,7 @@ Teste si les chaînes \argu{chaineA} et \argu{chaineB} sont égales, \emph{sauf}
 \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;
-	\item Il est possible d'évaluer des expressions algébriques en utilisant la primitive \verb|\numexpr| de $\varepsilon$-\TeX{}, en gardant à l'esprit qu'elle ne donne que des résultats entiers et qu'elle arrondit les résultats non entiers à l'entier le plus proche.
+	\item Le séparateur décimal peut être indifféremment la virgule ou le point.
 \end{Conditions}
 
 \exemple|\IfEq{a1b2c3}{a1b2c3}{vrai}{faux}|
@@ -390,7 +400,6 @@ Teste successivement si \argu{chaine} est égale à \argu{chaine1}, \argu{chaine
 \exemple|\IfEqCase{0.5}{{0}{zero}{.5}{moitié}{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
@@ -465,7 +474,7 @@ Dans \argu{chaine}, renvoie ce qui se trouve entre\footnote{Au sens strict, c'es
 \exemple*|\StrBetween[3,2]{abracadabra}{a}{bra}|
 
 \subsubsection{\ttfamily\textbackslash StrSubstitute}
-\verb|\StrSubstitute|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
+\verb|\StrSubstitute|\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
 \smallskip
 
 L'argument optionnel \argu{nombre} vaut 0 par défaut.\par\smallskip
@@ -492,7 +501,7 @@ Dans \argu{chaine}, la macro remplace les \argu{nombre} premières occurrences d
 \exemple|\StrSubstitute[4]{a1a2a3}{a}{B}|
 
 \subsubsection{\ttfamily\textbackslash StrDel}
-\verb|\StrDel|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
+\verb|\StrDel|\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
 \smallskip
 
 L'argument optionnel \argu{nombre} vaut 0 par défaut.\par\smallskip
@@ -513,38 +522,16 @@ Supprime les \argu{nombre} premières occurrences de \argu{chaineA} dans \argu{c
 \exemple|\StrDel{a bc def }{ }|
 \exemple*|\StrDel{a bc def }{def}|
 
-\subsubsection{\ttfamily\textbackslash StrSplit}
-\verb|\StrSplit|\etoile\ARGU{chaine}\ARGU{nombre}\ARGU{chaineA}\ARGU{chaineB}
-\smallskip
-
-La \argu{chaine}, est coupée en deux chaînes après le caractère se situant à la position \argu{nombre}. La partie gauche est assigné à la séquence de contrôle \argu{chaineA} et la partie droite à \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\footnote{Voir les explications sur l'argument venant en dernière position page~\pageref{argumentoptionnel}.} 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}
-
-\setverbdelim{=}
-\exemple=\StrSplit{abcdef}{4}{\csA}{\csB}résultats : |\csA| et |\csB|=
-\exemple=\StrSplit{a b c }{2}{\csA}{\csB}résultats : |\csA| et |\csB|=
-\exemple=\StrSplit{abcdef}{1}{\csA}{\csB}résultats : |\csA| et |\csB|=
-\exemple=\StrSplit{abcdef}{5}{\csA}{\csB}résultats : |\csA| et |\csB|=
-\exemple=\StrSplit{abcdef}{9}{\csA}{\csB}résultats : |\csA| et |\csB|=
-\exemple=\StrSplit{abcdef}{-3}{\csA}{\csB}résultats : |\csA| et |\csB|=
-\setverbdelim{|}
-
 \subsubsection{\ttfamily\textbackslash StrGobbleLeft}
-\verb|\StrGobbleLeft|\etoile\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrGobbleLeft|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
 \smallskip
 
-Dans \argu{chaine}, enlève les \argu{nombre} premiers caractères de gauche.\medskip
+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$, aucun caractère n'est supprimé.
-	\item Si \argu{nombre}${}\geqslant{}$\argu{longueurChaine}, tous les caractères sont supprimés.
+	\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}
 
 \exemple*|\StrGobbleLeft{xstring}{2}|
@@ -554,15 +541,15 @@ Dans \argu{chaine}, enlève les \argu{nombre} premiers caractères de gauche.\me
 \exemple*|\StrGobbleLeft{a bc def }{4}|
 
 \subsubsection{\ttfamily\textbackslash StrLeft}
-\verb|\StrLeft|\etoile\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\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$, aucun caractère n'est retourné.
-	\item Si \argu{nombre}${}\geqslant{}$\argu{longueurChaine}, tous les caractères sont retournés.
+	\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}
 
 \exemple*|\StrLeft{xstring}{2}|
@@ -572,10 +559,10 @@ Dans \argu{chaine}, renvoie la sous-chaîne de gauche de longueur \argu{nombre}.
 \exemple*|\StrLeft{a bc def }{5}|
 
 \subsubsection{\ttfamily\textbackslash StrGobbleRight}
-\verb|\StrGobbleRight|\etoile\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrGobbleRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
 \smallskip
 
-Agit comme \verb|\StrGobbleLeft|, mais enlève les caractères à droite de \argu{chaine}.
+Agit comme \verb|\StrGobbleLeft|, mais enlève les \USs à droite de \argu{chaine}.
 
 \exemple*|\StrGobbleRight{xstring}{2}|
 \exemple*|\StrGobbleRight{xstring}{9}|
@@ -584,10 +571,10 @@ Agit comme \verb|\StrGobbleLeft|, mais enlève les caractères à droite de \arg
 \exemple*|\StrGobbleRight{a bc def }{4}|
 
 \subsubsection{\ttfamily\textbackslash StrRight}
-\verb|\StrRight|\etoile\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
 \smallskip
 
-Agit comme \verb|\StrLeft|, mais renvoie les caractères à la droite de \argu{chaine}.
+Agit comme \verb|\StrLeft|, mais renvoie les \USs à la droite de \argu{chaine}.
 
 \exemple*|\StrRight{xstring}{2}|
 \exemple*|\StrRight{xstring}{9}|
@@ -596,14 +583,14 @@ Agit comme \verb|\StrLeft|, mais renvoie les caractères à la droite de \argu{c
 \exemple*|\StrRight{a bc def }{5}|
 
 \subsubsection{\ttfamily\textbackslash StrChar}
-\verb|\StrChar|\etoile\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrChar|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
 \smallskip
 
-Renvoie le caractère à la position \argu{nombre} dans la chaîne \argu{chaine}.\medskip
+Renvoie l'\US à la position \argu{nombre} dans la chaîne \argu{chaine}.\medskip
 
 \begin{Conditions}
-	\item Si \argu{chaine} est vide, aucun caractère n'est renvoyé;
-	\item Si \argu{nombre}${}\leqslant0$ ou si \argu{nombre}${}>{}$\argu{longueurChaine}, aucun caractère n'est renvoyé.
+	\item Si \argu{chaine} est vide, aucune \US n'est renvoyée;
+	\item Si \argu{nombre}${}\leqslant0$ ou si \argu{nombre}${}>{}$\argu{longueurChaine}, aucune \US n'est renvoyée.
 \end{Conditions}
 
 \exemple|\StrChar{xstring}{4}|
@@ -612,18 +599,18 @@ Renvoie le caractère à la position \argu{nombre} dans la chaîne \argu{chaine}
 \exemple|\StrChar{a bc def }{6}|
 
 \subsubsection{\ttfamily\textbackslash StrMid}
-\verb|\StrMid|\etoile\ARGU{chaine}\ARGU{nombreA}\ARGU{nombreB}\arguC{nom}
+\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-à-dire que les chaînes \guill{frontière} sont renvoyés.} les positions \argu{nombreA} et \argu{nombreB}.\medskip
+Dans \argu{chaine}, renvoie la sous chaîne se trouvant entre\footnote{Au sens large, c'est-à-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{nombreA}${}>{}$\argu{nombreB}, alors rien n'est renvoyé;
-	\item Si \argu{nombreA}${}<1$ et \argu{nombreB}${}<1$ alors rien n'est renvoyé;
-	\item Si \argu{nombreA}${}>{}$\argu{longueurChaine} et \argu{nombreB}${}>{}$\argu{longueurChaine}, alors rien n'est renvoyé;
-	\item Si \argu{nombreA}${}<1$, alors la macro se comporte comme si \argu{nombreA}${}=1$;
-	\item Si \argu{nombreB}${}>{}$\argu{longueurChaine}, alors la macro se comporte comme si \argu{nombreB}${}={}$\argu{longueurChaine}.
+	\item Si \argu{nombre1}${}>{}$\argu{nombre2}, alors rien n'est renvoyé;
+	\item Si \argu{nombre1}${}<1$ et \argu{nombre2}${}<1$ alors rien n'est renvoyé;
+	\item Si \argu{nombre1}${}>{}$\argu{longueurChaine} et \argu{nombre2}${}>{}$\argu{longueurChaine}, alors rien n'est renvoyé;
+	\item Si \argu{nombre1}${}<1$, alors la macro se comporte comme si \argu{nombre1}${}=1$;
+	\item Si \argu{nombre2}${}>{}$\argu{longueurChaine}, alors la macro se comporte comme si \argu{nombre2}${}={}$\argu{longueurChaine}.
 \end{Conditions}
 
 \exemple|\StrMid{xstring}{2}{5}|
@@ -636,7 +623,7 @@ Dans \argu{chaine}, renvoie la sous chaîne se trouvant entre\footnote{Au sens l
 
 \subsection{Les macros renvoyant des nombres}
 \subsubsection{\ttfamily\textbackslash StrLen}
-\verb|\StrLen|\etoile\ARGU{chaine}\arguC{nom}
+\verb|\StrLen|\ARGU{chaine}\arguC{nom}
 \smallskip
 
 Renvoie la longueur de \argu{chaine}.
@@ -646,7 +633,7 @@ Renvoie la longueur de \argu{chaine}.
 \exemple|\StrLen{a bc def }|
 
 \subsubsection{\ttfamily\textbackslash StrCount}
-\verb|\StrCount|\etoile\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
+\verb|\StrCount|\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
 \smallskip
 
 Compte combien de fois \argu{chaineA} est contenue dans \argu{chaine}.\par\medskip
@@ -661,7 +648,7 @@ Compte combien de fois \argu{chaineA} est contenue dans \argu{chaine}.\par\medsk
 \exemple|\StrCount{aaaaaa}{aa}|
 
 \subsubsection{\ttfamily\textbackslash StrPosition}
-\verb|\StrPosition|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
+\verb|\StrPosition|\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
 \smallskip
 
 L'argument optionnel \argu{nombre} vaut 1 par défaut.\par\smallskip
@@ -690,7 +677,7 @@ Cette macro peut fonctionner avec 2 tolérances : la tolérance \guill{normale}
 
 \begin{itemize}
 	\item La tolérance normale, activée par la commande \verb|\comparenormal|.\par
-	La macro compare successivement les caractères de gauche à droite des chaînes \argu{chaineA} et \argu{chaineB} jusqu'à 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.
+	La macro compare successivement les \US de gauche à droite des chaînes \argu{chaineA} et \argu{chaineB} jusqu'à 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}
@@ -728,18 +715,61 @@ Exemples en tolérance stricte :\par\comparestrict
 \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 tous les arguments 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é.
+La macro \verb|\fullexpandarg| est appelée par défaut, ce qui fait que certains arguments 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 des arguments des macros (et ainsi revenir au comportement normal de \TeX) en invoquant \verb|\noexpandarg| ou \verb|\normalexpandarg| qui sont synonymes.\medskip
+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 des arguments que l'on appelle avec \verb|\expandarg|. Dans ce cas, le \textbf{premier lexème} de chaque argument est développé \emph{une fois} avant que la macro ne soit appelée. Dans le cas où un argument contient plus d'un lexème, les lexèmes qui suivent le premier ne sont pas développés du tout (on peut contourner cette limitation et faire appel, au préalable, à la macro \verb|\scancs*|, voir page~\pageref{scancs}).\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 lexème} de ces arguments est développé \emph{une fois} avant que la macro ne soit appelée. Si l'argument contient plus d'un lexème, les lexèmes qui suivent le premier ne sont pas développés (on peut contourner cette volontaire limitation et utiliser la macro \verb|\scancs*|, voir page~\pageref{scancs}).\medskip
 
 Les commandes \verb|\fullexpandarg|, \verb|\noexpandarg|, \verb|\normalexpandarg| et \verb|\expandarg| peuvent être appelées à 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 à la situation lors de la sauvegarde avec \verb|\restoreexpandmode|.
+On peut également mémoriser le mode de développement en cours avec \verb|\saveexpandmode|, le modifier par la suite et revenir à la situation lors de la sauvegarde avec \verb|\restoreexpandmode|.\medskip
+
+Dans la liste ci-dessous, on peut voir en \textcolor{red}{rouge} quels arguments sont soumis à l'éventuel développement pour chaque macro vue dans le chapitre précedent :\smallskip
+
+\newcommand\colorise{\color{red}}
+\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 autorisés dans les arguments}
- Tout d'abord, quelque soit le mode de développement choisi, \textbf{les lexèmes de catcode 6 et 14 (habituellement {\ttfamily\#} et {\ttfamily\%}) sont interdits dans tous les arguments}\footnote{Le lexème {\ttfamily\#} sera peut-être autorisé dans une future version !}.\bigskip
+Tout d'abord, quelque soit le mode de développement choisi, \textbf{les lexèmes de catcode 6 et 14 (habituellement {\ttfamily\#} et {\ttfamily\%}) sont interdits dans tous les arguments}\footnote{Le lexème {\ttfamily\#} sera peut-être autorisé dans une future version !}.\bigskip
 
 Lorsque le mode \verb|\fullexpandarg| est activé, les arguments sont évalués à l'aide de la primitive \verb|\edef| avant d'être transmis aux macros. Par conséquent, sont autorisés dans les arguments :
 \smallskip\parindent3em
@@ -753,16 +783,16 @@ Lorsque le mode \verb|\fullexpandarg| est activé, les arguments sont évalués
 \end{itemize}
 \parindent0pt\smallskip
 
-En revanche, certains caractères\footnote{Ces caractères s'obtiennent avec la touche \textsf{AtlGr}${}+{}$lettre sous les distributions GNU/Linux.} comme \officialeuro, \textcurrency, ¶, etc. généreront des erreurs.
+En revanche, sous UTF8, certains caractères\footnote{Ces caractères s'obtiennent avec la touche \textsf{AtlGr}${}+{}$lettre sous les distributions GNU/Linux.} comme \officialeuro, \textcurrency, ¶, etc. généreront des erreurs.
 \bigskip
 
 Lorsque les arguments ne sont plus développés au maximum avec \verb|\expandarg| ou \verb|\noexpandarg|, les caractères autorisés sont ceux cités ci-dessus auxquels il faut rajouter toute séquence de contrôle, même non définie, ainsi que les caractères précédemment cités (\officialeuro, \textcurrency, ¶, etc.).
 
 \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, même en faisant appel à \verb|\expandafter|.\medskip
+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-à-dire toutes sauf les tests et \verb|\StrSplit|, 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
+C'est pour cela que les macros renvoyant un résultat, c'est-à-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 à \verb|\Resultat| les 4 caractères de gauche de \verb|xstring| :\par
 \hspace{0.2\linewidth}\verb|\edef\Resultat{\StrLeft{xstring}{4}}|\par
@@ -775,14 +805,14 @@ Et cette imbrication non permise censée enlever le premier et le dernier caract
 \hspace{0.2\linewidth}\verb|\StrGobbleRight{xstring}{1}[\machaine]|\par
 \hspace{0.2\linewidth}\verb|\StrGobbleleft{\machaine}{1}|\par
 
-\subsection{Lecture des arguments}
+\subsection{Traitement des arguments}
 \label{developpementarguments}
-\subsubsection{Lecture à l'\US prés}
-Les macros de \Xstring traitent les arguments \US par \US. Dans le code \TeX{}, une \US est soit :\smallskip\parindent3em
+\subsubsection{Traitement à 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 :\quad{\ttfamily\string\def\string\@gobble\string#1\string{\string}}} est soit :\smallskip\parindent3em
 
 \begin{itemize}
 	\item une séquence de contrôle;
-	\item un groupe, c'est à dire une suite de caractères située entre deux accolades équilibrées;
+	\item un groupe, c'est à dire une suite de lexèmes 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
@@ -812,10 +842,10 @@ Que va t-il arriver si l'on se place sous \verb|\noexpandarg| et que l'on demand
 \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. On voit qu'on n'obtient pas vraiment un \guill{caractère}, mais cela était prévisible : il s'agit d'une \US.
+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 principal, \Xstring considère les groupes entre accolades comme \USs fermées dans lesquelles \Xstring ne regarde pas.
+Par défaut, la commande \verb|\noexploregroups| est appelée et donc dans l'argument à examiner qui contient la chaîne de lexèmes, \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
 
@@ -862,26 +892,23 @@ Voyons ce que cela signifie sur un exemple : mettons que l'on veuille renvoyer c
 	\StrBefore[2]{\a1{\b1\a2}\a3}{\a}[\mycs]
 	\meaning\mycs
 \end{minipage}
-\fullexpandarg\noexploregroups
 \medskip
 
-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, à l'exception de \verb|\IfInteger|, \verb|\IfDecimal|, \verb|\IfStrEq|, \verb|\StrEq| et \verb|\StrCompare| qui sont insensibles au mode d'exploration en cours.
+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, à 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 à la situation lors de la sauvegarde avec \verb|\restoreexploremode|.
 
-\subsection{Catcodes des arguments, macros étoilées}
+\subsection{Catcodes et macros étoilées}
 \label{macrosetoilees}
-Les macros présentées ici tiennent compte des catcodes des caractères constituant les arguments. Il faut donc garder à l'esprit, particulièrement lors des tests, que les caractères \emph{et leurs catcodes} sont examinés.\medskip
+Les macros de \Xstring tiennent compte des catcodes des lexèmes constituant les arguments. Il faut donc garder à l'esprit, particulièrement lors des tests, que les lexèmes \emph{et leurs catcodes} sont examinés.\medskip
 
 Par exemple, ces 2 arguments :\par\smallskip
 \hfil\verb|{\string a\string b}|\qquad et\qquad\verb|{ab}|\hfil{}\par\smallskip
-ne se développent pas en 2 arguments égaux au yeux de \Xstring. Dans le premier cas, à 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 comme \verb|\string|, \verb|\detokenize|, \verb|\meaning|, \verb|\jobname|, \verb|\fontname|, \verb|\romannumeral|, etc.\medskip
+ne se développent pas en 2 arguments égaux aux yeux de \Xstring. Dans le premier cas, à 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. Celles-ci convertissent tous leurs 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.\medskip
-
-\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
+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 (à 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\smallskip
 \begin{minipage}[r]{0.6\linewidth}
@@ -897,12 +924,214 @@ Voici un exemple :\par\smallskip
 	\IfStrEq*{\string a\string b}{ab}{vrai}{faux}
 \end{minipage}\smallskip
 
-Dans l'exemple ci-dessus, après développement (on suppose que \verb|\fullexpandarg| est actif), le premier argument contient \verb|{ab}| où, à cause de \verb|\string|, les 2 caractères ont un catcode de 12. Le deuxième argument est \verb|{ab}| où les caractères ont leurs catcodes naturels de 11. Les chaînes n'étant pas égales à cause des catcodes, le test est donc \emph{négatif} dans la version non étoilée.\bigskip
+Les chaînes n'étant pas égales à 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. Ainsi 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{red}{rouge} quels arguments seront détokenisé lorsque l'étoile sera employée :\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 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 :\smallskip
 
-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. Ainsi 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{}.
+\verb|\StrFindGroup|\ARGU{argument}\ARGU{identifiant}\arguC{nom}\medskip
 
-\section{Autres macros pour une aide à 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 cela ne suffise pas. Ce chapitre présente d'autres macros qui permettent de contourner certaines limitations.
+Lorsque le groupe caractérisé par l'identifiant n'existe pas, une chaîne vide sera assignée à la séquence de contrôle \argu{nom}. Si le groupe existe, ce groupe \emph{avec ses accolades} sera assigné à \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'à 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 :\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 :\smallskip
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\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\par
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\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\par
+\end{minipage}
+\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 à 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| :\smallskip
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\exploregroups
+	char no 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
+	\string\groupID = \groupID\par
+	char no 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
+	\string\groupID = \groupID\par
+	char no 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
+	\string\groupID = \groupID\par
+	char no 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
+	\string\groupID = \groupID
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\exploregroups
+	char no 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
+	\string\groupID = \groupID\par
+	char no 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
+	\string\groupID = \groupID\par
+	char no 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
+	\string\groupID = \groupID\par
+	char no 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
+	\string\groupID = \groupID
+\end{minipage}
+
+\subsection{Coupure d'une chaîne, la macro {\ttfamily\textbackslash StrSplit}}
+\label{StrSplit}
+Voici la syntaxe de cette macro :\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 à la position \argu{nombre}. La partie gauche est assigné à la séquence de contrôle \argu{chaineA} et la partie droite à \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}
+
+\setverbdelim{=}
+\exemple=\StrSplit{abcdef}{4}{\csA}{\csB}résultats : |\csA| et |\csB|=
+\exemple=\StrSplit{a b c }{2}{\csA}{\csB}résultats : |\csA| et |\csB|=
+\exemple=\StrSplit{abcdef}{1}{\csA}{\csB}résultats : |\csA| et |\csB|=
+\exemple=\StrSplit{abcdef}{5}{\csA}{\csB}résultats : |\csA| et |\csB|=
+\exemple=\StrSplit{abcdef}{9}{\csA}{\csB}résultats : |\csA| et |\csB|=
+\exemple=\StrSplit{abcdef}{-3}{\csA}{\csB}résultats : |\csA| et |\csB|=
+\setverbdelim{|}\medskip
+
+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 tansque l'autre sera vide comme on le voit sur cet exemple :\smallskip
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\exploregroups
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\exploregroups
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB
+\end{minipage}
+\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 à 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
+
+\begin{minipage}[r]{0.6\linewidth}
+\hfill
+\begin{boxedverbatim}
+	\exploregroups
+	Macro non étoilée :\par
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID = \groupID\par
+	Macro étoilée :\par
+	\StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID\ = \groupID
+\end{boxedverbatim}
+\hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\exploregroups
+	Macro non étoilée :\par
+	\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID = \groupID\par
+	Macro étoilée :\par
+	\StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
+	\meaning\strA\par
+	\meaning\strB\par
+	\string\groupID\ = \groupID
+\end{minipage}
 
 \subsection{Assigner un contenu verb, la macro \ttfamily\textbackslash verbtocs}
 \label{verbtocs}
@@ -913,10 +1142,10 @@ La macro \verb|\verbtocs| permet le lire le contenu d'un \guill{verb} qui peut c
 
 \argu{nom} est le nom d'une séquence de contrôle qui recevra à 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 caractère délimitant le contenu verb est \guill{|}, étant entendu que ce caractère ne peut être à 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 à tout moment le caractère délimitant le contenu verb par la macro :\par\medskip
-\hfill\verb|\setverbdelim|\ARGU{caractère}\hfill{}\smallskip
+Par défaut, le lexème délimitant le contenu verb est \guill{|}, étant entendu que ce lexème ne peut être à 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 à tout moment le lexème délimitant le contenu verb par la macro :\par\medskip
+\hfill\verb|\setverbdelim|\ARGU{lexème}\hfill{}\smallskip
 
-Tout \argu{caractère} ayant un catcode de 11 ou 12 peut être utilisé\footnote{Plusieurs caractères 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 caractères.}.\medskip
+Tout \argu{lexème} peut être utilisé\footnote{Plusieurs lexèmes 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 lexèmes.}.\medskip
 
 Concernant ces arguments verb, il faut tenir compte des deux points suivants :
 \begin{itemize}
@@ -945,7 +1174,7 @@ Le processus inverse de ce qui a été vu au dessus consiste à interpréter une
 \hfill\verb|\tokenize|\ARGU{nom}\ARGU{séquences de contrôle}\hfill{}
 \smallskip
 
-\argu{séquences de contrôle} est développée le plus possible si l'on a invoqué \verb|\fullexpandarg|; elle n'est pas développée si l'on a invoqué \verb|\normalexpandarg| ou \verb|\expandarg|. Après développement éventuel, la suite de caractères est transformeé en tokens puis assigné à l 'aide d'un \verb|\def| à la séquence de contrôle \argu{nom}.\medskip
+\argu{séquences de contrôle} est développée le plus possible si l'on a invoqué \verb|\fullexpandarg|; elle n'est pas développée si l'on a invoqué \verb|\normalexpandarg| ou \verb|\expandarg|. Après développement éventuel, la suite de caractères est transformeé en lexèmes puis assigné à l 'aide d'un \verb|\def| à 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\medskip
 \begin{minipage}[r]{0.6\linewidth}
@@ -1077,7 +1306,7 @@ Dans l'exemple artificiel\footnote{On peut agir beaucoup plus simplement en util
 		\newcommand\bracearg[1]{%
 		  \def\text{#1}%
 		  \scancs*{\result}{\Ob\text\Cb}%
-		  result%
+		  \result%
 		}
 		\bracearg{xstring}\par
 		\bracearg{\a}
@@ -1103,14 +1332,15 @@ On peut utiliser la macro \verb|\StrRemoveBraces| dont voici la syntaxe :\smalls
 \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 haut niveau avec \verb|\noexploregroups|.\medskip
+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
 
+\vbox{%
 \exemple|\noexploregroups|
 \exemple|\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]|
 \exemple|\meaning\mycs|
 \exemple|\exploregroups|
 \exemple|\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]|
-\exemple|\meaning\mycs|
+\exemple|\meaning\mycs|}
 
 \subsection{Exemples d'utilisation en programmation}
 \label{exemples}
@@ -1155,6 +1385,64 @@ Ainsi, \verb|\empty| est développée en \guill{rien} et il reste dans les 2 der
 La séquence de contrôle \verb|\empty| est donc un \guill{hack} pour \verb|\expandarg| : elle permet de bloquer le développement du 1\ier{} lexème ! On aurait d'ailleurs pu utiliser \verb|\noexpand| au lieu de \verb|\empty| pour obtenir le même résultat.
 
 \subsubsection{Exemple 2}
+On cherche ici à écrire une commande qui efface \verb|n| unités syntaxiques dans une chaîne à partir d'une position donnée, et affecte le résultat dans une séquence de contrôle dont on peut choisir le nom.
+
+On va appeler cette macro \verb|StringDel| et lui donner la syntaxe :
+
+\hfil\verb|\StringDel{chaine}{position}{n}{\nom_resultat}|\hfil{}
+\medskip
+
+On peut procéder ainsi : prendre la chaîne se trouvant juste avant la position, la sauvegarder. Ensuite enlever \verb|n + position| \USs à la chaîne, et concaténer ce résultat à ce qui a été sauvegardé auparavant. Cela donne le code suivant :\medskip
+
+\begin{minipage}[r]{0.7\linewidth}
+	\hfill
+	\begin{boxedverbatim}
+		\newcommand\StringDel[4]{%
+			\begingroup
+			\expandarg% portée locale au groupe
+			\StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
+			\StrGobbleLeft{\empty#1}{\number\numexpr#2+#3-1}[\StrA]%
+			\expandafter\expandafter\expandafter\endgroup
+			\expandafter\expandafter\expandafter\def
+			\expandafter\expandafter\expandafter#4%
+			\expandafter\expandafter\expandafter{\expandafter#4\StrA}%
+			}
+
+		\noexploregroups
+		\StringDel{abcdefgh}{2}{3}{\cmd}
+		\meaning\cmd
+
+		\StringDel{a\textbf{1}b\textbf{2c}3d}{3}{4}{\cmd}
+		\meaning\cmd
+	\end{boxedverbatim}
+ \hspace*{0.3cm}
+\end{minipage}%
+\begin{minipage}[r]{0.3\linewidth}
+	\newcommand\StringDel[4]{%
+		\begingroup
+		\expandarg% portée locale au groupe
+		\StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
+		\StrGobbleLeft{\empty#1}{\number\numexpr#2+#3-1}[\StrA]%
+		\expandafter\expandafter\expandafter\endgroup
+		\expandafter\expandafter\expandafter\def
+		\expandafter\expandafter\expandafter#4%
+		\expandafter\expandafter\expandafter{\expandafter#4\StrA}%
+		}
+
+	\noexploregroups
+	\StringDel{abcdefgh}{2}{3}{\cmd}
+	\meaning\cmd
+
+	\StringDel{a\textbf{1}b\textbf{2c}3d}{3}{4}{\cmd}
+	\meaning\cmd
+\end{minipage}\fullexpandarg
+\bigskip
+
+Pour la concaténation, on aurait pu procéder différemment en utilisant la macro \verb|\g@addto@macro| de \LaTeX{}. Cela évite aussi de laborieux \guill{ponts} d'\verb|\expandafter|. Il suffit alors de remplacer l'assignation par\footnote{À condition d'avoir provisoirement changé le code de catégorie de \og{\ttfamily\string@}\fg{} en écrivant la macro entre les commandes {\ttfamily\string\makeatletter} et {\ttfamily\string\makeatother}} :\smallskip
+
+\hfil\verb|\expandafter\g@addto@macro\expandafter#4\expandafter{\StrA}\endgroup|\hfil{}
+
+\subsubsection{Exemple 3}
 Cherchons à écrire une macro \verb|\tofrac| qui transforme une écriture du type \guill{a/b} par \guill{$\frac{a}{b}$}.\medskip
 
 Tout d'abord, annulons le développement des arguments avec \verb|\noexpandarg| : nous n'avons pas besoin de développement ici. Il suffit d'isoler ce qui se trouve avant et après la 1\iere{} occurrence de \guill{/} (on suppose qu'il n'y a qu'une seule occurrence), le mettre dans les séquences de contrôle \verb|\avant| et \verb|\apres| et simplement appeler la macro \verb|\frac| :\medskip
@@ -1187,10 +1475,10 @@ Tout d'abord, annulons le développement des arguments avec \verb|\noexpandarg|
 	\tofrac{x+\sqrt{x}/\sqrt{x^2+x+1}}
 \end{minipage}\fullexpandarg
 
-\subsubsection{Exemple 3}
+\subsubsection{Exemple 4}
 Soit une phrase composée de texte. Dans cette phrase, essayons construire une macro qui mette en gras le 1\ier{} mot qui suit un mot donné. On entend par mot une suite de caractère ne commençant ni ne finissant par un espace. Si le mot n'existe pas dans la phrase, rien n'est fait.\medskip
 
-On va écrire une macro \verb|\grasapres| qui effectue ce travail. On appelle \verb|\StrBehind| qui assigne à \verb|\mot| ce qui se trouve après la 1\iere{} occurrence du mot (précédé et suivi de son espace). Ensuite, le mot à mettre en gras est ce qui se trouve avant le 1\ier{} espace dans la séquence de contrôle \verb|\mot|. Remarquons que ceci reste vrai même si le mot à mettre en gras est le dernier de l'argument car un espace a été rajouté à la fin de l'argument par \verb|{#1 }| lors de l'appel à \verb|\StrBehind|. Remarquons aussi que \verb|\expandarg| a été appelé et donc, le premier lexème de l'argument \verb|\textbf{\mot}| est développé 1 fois, \emph{lui aussi} ! Cela est possible (heureusement sinon, il aurait fallu faire autrement et utiliser le hack de l'exemple précédent) puisque le 1-développement de cette macro de \LaTeX{} est \og\verb|\protect\textbf|\fg{}\footnote{En toute rigueur, il aurait fallu écrire :\par\hspace{2em}{\ttfamily\string\StrSubstitute[1]\{\string#1\}\{\string\mot\}\{\string\expandafter\string\textbf\string\expandafter\{\string\mot\}\}}\\De cette façons, dans {\ttfamily\{\string\expandafter\string\textbf\string\expandafter\{\string\mot\}\}}, la séquence de contrôle {\ttfamily\string\mot} est développée \textbf{avant} que l'appel à la macro ne se fasse. Cela est dû à l'{\ttfamily\string\expandafter} placé en début d'argument qui est développé à cause de {\ttfamily\string\expandarg} et grace à l'autre {\ttfamily\string\expandafter}, provoque le développement de {\ttfamily\string\mot}}.\medskip
+On va écrire une macro \verb|\grasapres| qui effectue ce travail. On appelle \verb|\StrBehind| qui assigne à \verb|\mot| ce qui se trouve après la 1\iere{} occurrence du mot (précédé et suivi de son espace). Ensuite, le mot à mettre en gras est ce qui se trouve avant le 1\ier{} espace dans la séquence de contrôle \verb|\mot|. Remarquons que ceci reste vrai même si le mot à mettre en gras est le dernier de l'argument car un espace a été rajouté à la fin de l'argument par \verb|{#1 }| lors de l'appel à \verb|\StrBehind|. Remarquons aussi que \verb|\expandarg| a été appelé et donc, le premier lexème de l'argument \verb|\textbf{\mot}| est développé 1 fois, \emph{lui aussi} ! Cela est possible (heureusement sinon, il aurait fallu faire autrement et utiliser le hack de l'exemple précédent) puisque le 1-développement de cette macro de \LaTeX{} est \og\verb|\protect\textbf|\fg{}\footnote{En toute rigueur, il aurait fallu écrire :\par\hspace{2em}{\ttfamily\string\StrSubstitute[1]\{\string#1\}\{\string\mot\}\{\string\expandafter\string\textbf\string\expandafter\{\string\mot\}\}}\newline De cette façon, dans {\ttfamily\{\string\expandafter\string\textbf\string\expandafter\{\string\mot\}\}}, la séquence de contrôle {\ttfamily\string\mot} est développée \textbf{avant} que l'appel à la macro ne se fasse. Cela est dû à l'{\ttfamily\string\expandafter} placé en début d'argument qui est développé à cause de {\ttfamily\string\expandarg} et grace à l'autre {\ttfamily\string\expandafter}, provoque le développement de {\ttfamily\string\mot}}.\medskip
 
 \begin{minipage}[r]{0.6\linewidth}
 	\hfill
@@ -1227,7 +1515,7 @@ On va écrire une macro \verb|\grasapres| qui effectue ce travail. On appelle \v
 	\grasapres{Le package xstring est nouveau}{est}
 \end{minipage}\fullexpandarg
 
-\subsubsection{Exemple 4}
+\subsubsection{Exemple 5}
 Soit un argument commençant par au moins 3 séquences de contrôles avec leurs éventuels arguments. Comment intervertir les 2 premières séquences de contrôle de telle sorte qu'elles gardent leurs arguments ? On va pour cela écrire une macro \verb|swaptwofirst|.
 
 Cette fois ci, on ne peut pas chercher le seul caractère \og\verb|\|\fg{} (de catcode 0) dans un argument. Nous serons obligé de détokeniser l'argument, c'est ce que fait \verb|\scancs[0]\chaine{#1}| qui met le résultat dans \verb|\chaine|. Ensuite, on cherchera dans cette séquence de contrôle les occurrences de \verb|\antislash| qui contient le caractère \og\verb|\|\fg{} de catcode 12, assigné avec un \verb|\verbtocs| écrit \emph{en dehors\footnote{En effet, la macro {\tt\string\verbtocs} et son argument verb est interdite à l'intérieur de la définition d'une macro.}} du corps de la macro. La macro se termine par une retokenisation, une fois que les chaînes \verb|\avant| et \verb|\apres| aient été échangées.\medskip
@@ -1269,96 +1557,41 @@ Cette fois ci, on ne peut pas chercher le seul caractère \og\verb|\|\fg{} (de c
 	\swaptwofirst{\Large\underline{A}\textbf{B}123}
 \end{minipage}
 
-\subsubsection{Exemple 5}
-Soit une séquence de contrôle \verb|\myCS| définie par un \verb|\def| contenant des séquences de contrôles et des groupes entre accolades. Essayons de trouver le $n$\ieme{} groupe, c'est à dire ce qui se trouve entre la $n$\ieme{} paire d'accolades équilibrées. On prendra comme exemple une séquence de contrôle contenant :\par\medskip
-\hfill\verb|\a{1\b{2}}\c{3}\d{4\e{5}\f{6{7}}}|\hfill{}\medskip
+\subsubsection{Exemple 6}
+Dans une chaîne, on cherche ici à isoler le n\ieme{} mot se trouvant entre 2 délimiteurs précis. Pour cela on écrira une macro \verb|\findword| admettant comme argument optionnel le délimiteur de mot (l'espace par défaut), 1 argument contenant la chaîne, 1 argument contenant le nombre correspondant au n\ieme{} mot cheché.\medskip
+
+La macro \verb|\findword| utilise \verb|\StrBetween| et \verb|\numexpr| de façon astucieuse :\medskip
 
 \begin{minipage}[r]{0.6\linewidth}
 	\hfill
 	\begin{boxedverbatim}
-		\fullexpandarg
-		\newcount\occurr \newcount\nbgroup
-		\newcommand\findgroup[2]{%
-		  \scancs[1]{\chaine}{#2}%
-		  \occurr=0
-		  \nbgroup=0
-		  \def\findthegroup{%
-		    \StrBehind{\chaine}{\Obr}[\remain]%
-		    \advance\occurr by 1% accolade fermante suivante
-		    \StrBefore[\the\occurr]{\remain}{\Cbr}[\group]%
-		    \StrCount{\group}{\Obr}[\nbA]%
-		    \StrCount{\group}{\Cbr}[\nbB]%
-		    \ifnum\nbA=\nbB% accolades équilibrées ?
-		      \advance\nbgroup by 1
-		      \ifnum\nbgroup<#1% si c'est pas le bon groupe
-		        \StrBehind{\chaine}{\group}[\chaine]%
-		        \occurr=0% on initialise \chaine et \occur
-		        \expandafter\expandafter\expandafter
-		        \findthegroup\expandafter% et on recommence
-		      \fi
-		    \else% accolades non équilibrées ?
-		      % cherche accolade fermante suivante
-		      \expandafter\findthegroup
-		    \fi}
-		  \findthegroup
-		  \group}
-
-		\verbtocs{\Obr}|{|
-		\verbtocs{\Cbr}|}|
-		\def\myCS{\a{1\b{2}}\c{3}\d{4\e{5}\f{6{7}}}}
-		groupe 1: \findgroup{1}{\myCS}\par
-		groupe 2: \findgroup{2}{\myCS}\par
-		groupe 3: \findgroup{3}{\myCS}
+	\newcommand\findword[3][ ]{%
+		\StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}}
+	\noexpandarg
+	|\findword{a bc d\textit{e f} gh}{3}|
+
+	|\findword[\@nil]{1 \@nil 2 3 \@nil4\@nil}{2}|
 	\end{boxedverbatim}
 	\hspace*{0.3cm}
 \end{minipage}%
 \begin{minipage}[r]{0.3\linewidth}
-	\fullexpandarg
-	\newcount\occurr \newcount\nbgroup
-	\newcommand\findgroup[2]{%
-		\scancs[1]{\chaine}{#2}%
-		\occurr=0
-		\nbgroup=0
-		\def\findthegroup{%
-		\StrBehind{\chaine}{\Obr}[\remain]%
-		\advance\occurr by 1% accolade fermante suivante
-		\StrBefore[\the\occurr]{\remain}{\Cbr}[\group]%
-		\StrCount{\group}{\Obr}[\nbA]%
-		\StrCount{\group}{\Cbr}[\nbB]%
-		\ifnum\nbA=\nbB% accolades équilibrées ?
-			\advance\nbgroup by 1
-			\ifnum\nbgroup<#1% si c'est pas le bon groupe
-			\StrBehind{\chaine}{\group}[\chaine]%
-			\occurr=0% on initialise \chaine et \occur
-			\expandafter\expandafter\expandafter
-				\findthegroup\expandafter% et on recommence
-			\fi
-		\else% accolades non équilibrées ?
-			% cherche accolade fermante suivante
-			\expandafter\findthegroup
-		\fi}
-		\findthegroup
-		\group}
-
-	\verbtocs{\Obr}|{|
-	\verbtocs{\Cbr}|}|
-	\def\myCS{\a{1\b{2}}\c{3}\d{4\e{5}\f{6{7}}}}
-	groupe 1: \findgroup{1}{\myCS}\par
-	groupe 2: \findgroup{2}{\myCS}\par
-	groupe 3: \findgroup{3}{\myCS}
-\end{minipage}
-\medskip
+	\newcommand\findword[3][ ]{%
+		\StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}}
+	\noexpandarg
+	|\findword{a bc d\textit{e f} gh}{3}|
 
-On peut observer qu'il faut deux compteurs, deux tests et une double récursivité pour trouver le bon groupe : un de chaque pour compter quelle accolade fermante va délimiter le groupe en cours, et l'autre pour compter quel groupe est examiné.\vspace{10pt}
+	|\findword[\@nil]{1 \@nil 2 3 \@nil4\@nil}{2}|
+\end{minipage}
 
+\bigskip\bigskip
 \begin{center}
 $\star$\par
 $\star$\quad$\star$
 \end{center}
-\vspace{10pt}
+\bigskip\bigskip
 
 C'est tout, j'espère que ce package vous sera utile !\par
-Merci de me signaler par email tout bug ou toute proposition d'amélioration\ldots\medskip
+Merci de me signaler par \href{mailto:unbonpetit@gmail.com}{email} tout bug ou toute proposition d'amélioration\ldots\medskip
 
 Christian Tellechea
 \end{document}
\ No newline at end of file
diff --git a/Master/texmf-dist/tex/generic/xstring/xstring.tex b/Master/texmf-dist/tex/generic/xstring/xstring.tex
index 9da9444bb2c..7e2b35779e5 100644
--- a/Master/texmf-dist/tex/generic/xstring/xstring.tex
+++ b/Master/texmf-dist/tex/generic/xstring/xstring.tex
@@ -1,15 +1,24 @@
 %  __________________________________________________
 % |                                                  |
 % |                                                  |
-% |                  xstring  v1.4b                  |
+% |                   xstring v1.5                   |
 % |                                                  |
-% |                 November 16 2008                 |
+% |                 December 31 2008                 |
 % |                                                  |
 % |__________________________________________________|
 %
 % This is xtring.tex
 %
-% Christian Tellechea 2008
+% "xstring" package consists of the 11 following files:
+%   xstring.tex (this file)
+%   xstring.sty
+%   README
+%   xstring_doc_fr.tex, xstring_doc_fr.pdf (manual in french)
+%   xstring_doc_en.tex, xstring_doc_en.pdf (manual in english)
+%   test_latex.tex, test_latex.pdf (test file with LaTeX)
+%   test_etex.tex, test_etex.pdf (test file with Plain eTeX)
+%
+% Christian Tellechea 2008-2009
 % email : unbonpetit@gmail.com
 % -------------------------------------------------------------------
 % This work may be distributed and/or modified under the
@@ -26,19 +35,10 @@
 %
 % The Current Maintainer of this work is Christian Tellechea
 % -------------------------------------------------------------------
-% This work consists of the files
-%   xstring.tex (this file)
-%   xstring.sty
-%   README
-%   xstring_doc_fr.tex, xstring_doc_fr.pdf (manual in french)
-%   xstring_doc_en.tex, xstring_doc_en.pdf (manual in english)
-%   test_latex.tex, test_latex.pdf (test file with LaTeX)
-%   test_etex.tex, test_etex.pdf (test file with Plain eTeX)
-%
-\def\xstringversion    {1.4b}
-\def\xstringdate       {2008/11/16}
-\def\xstringfrenchdate {16 novembre 2008}
-\def\xstringenglishdate{November $16^{\mathrm{th}}$ 2008}
+\def\xstringversion    {1.5}
+\def\xstringdate       {2008/12/31}
+\def\xstringfrenchdate {31 d\'ecembre 2008}
+\def\xstringenglishdate{December $31^{\mathrm{st}}$ 2008}
 \edef\CurrentAtCatcode{\the\catcode`\@}
 \catcode`\@=11
 \newwrite\@xs@unused% pour les messages
@@ -71,7 +71,7 @@
 	\def\@ifstar#1{\@ifnextchar *{\@firstoftwo{#1}}}
 	\long\def\@testopt#1#2{\@ifnextchar[{#1}{#1[{#2}]}}
 	\def\@empty{}
-\fi% fin des définitions LaTeX
+\fi% fin des d\'efinitions LaTeX
 
 % Gestion des messages d'erreur
 \def\@xs@linenumber{on input line \the\inputlineno}
@@ -97,37 +97,37 @@
 		\immediate\write\m@ne{Package xstring Info: #1}%
 	\endgroup}
 
-% Messages d'information pour situations particulières
+% Messages d'information pour situations particuli\`eres
 \def\@xs@BadNumArg   {\@xs@infowrite{numerical argument out of range}}
 \def\@xs@ArgNotFound {\@xs@infowrite{substring not found in string}}
 \def\@xs@ArgEmpty    {\@xs@infowrite{empty argument}}
 
-% Ouvre un groupe où les catcodes sont à 12 et à 10 pour les espaces
-% ensuite, appelle \@xs@ReadVerb qui lit un argument entre délimiteurs verb
+% Ouvre un groupe o\`u les catcodes sont \`a 12 et \`a 10 pour les espaces
+% ensuite, appelle \@xs@ReadVerb qui lit un argument entre d\'elimiteurs verb
 \def\@xs@MakeVerb{% lit 1 argument et le transforme en verb
-	\begingroup% groupe où les catcodes sont à 12 pour la lecture suivante
+	\begingroup% groupe o\`u les catcodes sont \`a 12 pour la lecture suivante
 		\def\do##1{\catcode`##112\relax}%
 		\dospecials% on entre dans le mode verb
 		\obeyspaces% et on tient compte des espaces
 		\@xs@ReadVerb}% et on va lire l'argument
 
-% Définit \@xs@ReadVerb qui lit un argument entre délimiteurs verb
-\def\setverbdelim#1{% définit quel est le délimiteur de verb
+% D\'efinit \@xs@ReadVerb qui lit un argument entre d\'elimiteurs verb
+\def\setverbdelim#1{% d\'efinit quel est le d\'elimiteur de verb
 	\expandafter\ifx\expandafter\@empty\detokenize\expandafter{\@xs@gobblefirstchar#1}\@empty
 	\else
 		\@xs@warningwrite{verb delimiter is not a single char}%
 	\fi
-	\def\@xs@ReadVerb##1#1##2#1{% lit ##2 qui est entre les délimiteurs de verb
+	\def\@xs@ReadVerb##1#1##2#1{% lit ##2 qui est entre les d\'elimiteurs de verb
 		\endgroup% on ferme le groupe
-		\@xs@afterreadverb{##2}}}% on appelle l'exécution de fin
+		\@xs@afterreadverb{##2}}}% on appelle l'ex\'ecution de fin
 
-% Assigne l'argument entre délimiteur verb dans la sc #1
+% Assigne l'argument entre d\'elimiteur verb dans la sc #1
 \def\verbtocs#1{%
 	\def\@xs@afterreadverb##1{\edef#1{##1}}%
 	\@xs@MakeVerb}
 
-% A l'aide d'un pont d'\expandafter, développe d'un niveau toutes
-% les uneités syntaxiques de #1 puis et assigne le résultat à \@xs@reserved@A
+% D\'eveloppe d'un niveau toutes les unit\'es syntaxiques
+% de #1 puis et assigne le r\'esultat \`a \@xs@reserved@A
 \def\@xs@expandallonelevel#1#2\@xs@nil{%
 	\expandafter\@xs@addtomacro\expandafter\@xs@reserved@A\expandafter{#1}%
 	\ifx\@empty#2\@empty
@@ -139,14 +139,14 @@
 \def\@xs@notestcs#1\@xs@nil{\relax}%
 \def\@xs@testcs#1#2\@xs@nil{%
 	\ifx\@empty#2\@empty
-	\else% si la séquence de contrôle n'est pas seule, on gueule
+	\else% si la s\'equence de contr\^ole n'est pas seule, on gueule
 		\@xs@errorwrite{third argument or its expansion^^Jis not a single control sequence! Use \string\scancs* instead of \string\scancs (see manual).}{With \scancs, the third argument (or one of its expansion) cannot contain^^Jmore than one control sequence. If so, use the starred version \scancs*,^^Jand read manual for more information about this starred version...}%
 	\fi}
 
-% \scancs développe #3 autant de fois que spécifié en #1
-% puis le développement obtenu est verbatimisé.
-% On utilise \@xs@expandalltodepth autant de fois que #1 le spécifie
-% puis on invoque \detokenize à la fin
+% \scancs d\'eveloppe #3 autant de fois que sp\'ecifi\'e en #1
+% puis le d\'eveloppement obtenu est verbatimis\'e.
+% On utilise \@xs@expandalltodepth autant de fois que #1 le sp\'ecifie
+% puis on invoque \detokenize \`a la fin
 \def\scancs{%
 	\@ifstar%
 		{\@xs@warningwrite{\string\scancs* has limitations: ^^Jif third argument or its expansion have braces or spaces,^^Jthey will be removed when scanned}%
@@ -156,15 +156,15 @@
 		 \@xs@scancs}}
 \def\@xs@scancs{\@ifnextchar[{\@xs@scancs@}{\@xs@scancs@[1]}}
 \def\@xs@scancs@[#1]#2#3{%
-% #1 : profondeur à développer avant de verbatimiser
+% #1 : profondeur \`a d\'evelopper avant de verbatimiser
 % #2 : nom de la sc recevant la chaine verb
-% #3 : nom de la sc à développer et à transformer en verb
-	\def\@xs@expandalltodepth##1{% développe de #1 niveaux toutes les sc de #3 et l'assigne à \@xs@reserved@B
-		\let\@xs@reserved@A\@empty%\def\@xs@reserved@A{}%
-		\ifnum##1<#1\relax% tant que la profondeur de développement n'est pas atteinte
-			\expandafter\@xs@testornot\@xs@reserved@B\@xs@nil% on teste éventuellement si le développement comporte 1 seule sc
-			\expandafter\@xs@expandallonelevel\@xs@reserved@B\@xs@nil% on développe tout d'un niveau
-			\let\@xs@reserved@B\@xs@reserved@A%\expandafter\def\expandafter\@xs@reserved@B\expandafter{\@xs@reserved@A}%
+% #3 : nom de la sc \`a d\'evelopper et \`a transformer en verb
+	\def\@xs@expandalltodepth##1{% d\'eveloppe de #1 niveaux toutes les sc de #3 et l'assigne \`a \@xs@reserved@B
+		\let\@xs@reserved@A\@empty%
+		\ifnum##1<#1\relax% tant que la profondeur de d\'eveloppement n'est pas atteinte
+			\expandafter\@xs@testornot\@xs@reserved@B\@xs@nil% on teste \'eventuellement si le d\'eveloppement comporte 1 seule sc
+			\expandafter\@xs@expandallonelevel\@xs@reserved@B\@xs@nil% on d\'eveloppe tout d'un niveau
+			\let\@xs@reserved@B\@xs@reserved@A%
 			\def\@xs@next{\expandafter\@xs@expandalltodepth\expandafter{\number\numexpr##1+1}}%
 			\expandafter\@xs@next% et on recommence
 		\fi}%
@@ -172,23 +172,23 @@
 	\@xs@expandalltodepth\z@
 	\expandafter\def\expandafter#2\expandafter{\detokenize\expandafter{\@xs@reserved@B}}}
 
-% Cette macro développe éventuellement #2
-% puis le transforme en token et l'assigne à #1
-\begingroup% on ouvre un groupe où...
-\catcode\z@12\relax% ...le caractère 0 a 12 pour catcode
+% Cette macro d\'eveloppe \'eventuellement #2
+% puis le transforme en token et l'assigne \`a #1
+\begingroup% on ouvre un groupe o\`u...
+\catcode\z@12\relax% ...le caract\`ere 0 a 12 pour catcode
 \gdef\tokenize#1#2{%
 	\begingroup
-		\@xs@def\@xs@reserved@A{#2}% on développe en accord avec \fullexpandarg ou \noexpandarg
+		\@xs@def\@xs@reserved@A{#2}% on d\'eveloppe en accord avec \fullexpandarg ou \noexpandarg
 		\def\@xs@AssignResult^^00##1^^00\@xs@nil{\gdef#1{##1}}% on assigne en tenant compte du \@xs@nil qui vient de la fin du fichier virtuel
-		\everyeof{\@xs@nil}% met un \@xs@nil à la fin du fichier virtuel
+		\everyeof{\@xs@nil}% met un \@xs@nil \`a la fin du fichier virtuel
 		\endlinechar\m@ne
 		\catcode\z@12\relax
 		\expandafter\@xs@AssignResult\scantokens\expandafter{\expandafter^^00\@xs@reserved@A^^00}% on fait l'assignation
 	\endgroup}%
 \endgroup
 
-% Macro très simple qui assigne ou affiche le résultat, selon la présence
-% ou non de #2 qui est l'argument optionnel venant en dernière position des macros
+% Macro tr\`es simple qui assigne ou affiche le r\'esultat, selon la pr\'esence
+% ou non de #2 qui est l'argument optionnel venant en derni\`ere position des macros
 \def\@xs@ReturnResult#1#2{%
 	\expandafter\ifx\expandafter\@empty\detokenize{#2}\@empty% pas de nom ?
 		#1% on affiche #1
@@ -198,31 +198,31 @@
 
 % Pas d'expansion des arguments
 \def\normalexpandarg{%
-	\let\@xs@def\def% on définit \@xs@call avec \def
+	\let\@xs@def\def% on d\'efinit \@xs@call avec \def
 	\def\@xs@expand##1{\unexpanded\expandafter{##1}}}
 \let\noexpandarg\normalexpandarg% synonyme
 
-% 1-développement de la 1è sc des arguments et non développement des autres
+% 1-d\'eveloppement du premier token des arguments
 \def\expandarg{%
-	\let\@xs@def\def% on définit \@xs@call avec \def
+	\let\@xs@def\def% on d\'efinit \@xs@call avec \def
 	\def\@xs@expand##1{\unexpanded\expandafter\expandafter\expandafter{##1}}}
 
-% Développement maximum des arguments
+% D\'eveloppement maximum des arguments
 \def\fullexpandarg{%
-	\let\@xs@def\edef% on définit\@xs@call avec \edef
+	\let\@xs@def\edef% on d\'efinit\@xs@call avec \edef
 	\def\@xs@expand##1{##1}}% et on neutralise \@xs@expand
 
 \def\saveexpandmode{\let\@xs@saved@def\@xs@defarg\let\@xs@saved@expand\@xs@expand}
 \def\restoreexpandmode{\let\@xs@defarg\@xs@saved@def\let\@xs@expand\@xs@saved@expand}
 
-% Cette macro interne prend la 1ere unité syntaxique de #1 et assigne le résultat à #2
+% Cette macro interne prend la 1ere unit\'e syntaxique de #1 et assigne le r\'esultat \`a #2
 \def\@xs@returnfirstsyntaxunit#1#2{%
 	\def\@xs@returnfirstsyntaxunit@i##1##2\@xs@nil{%
 		\ifx\@xs@toks\bgroup
 			\begingroup
-				\escapechar48\relax% 0 est le caractère d'échappement
+				\escapechar48\relax% 0 est le caract\`ere d'\'echappement
 				\expandafter\expandafter\expandafter\ifx\expandafter\@xs@returnfirstsyntaxunit@ii\detokenize{#1}\@xs@nil0%
-					\def\@xs@reserved@A{\def#2{##1}\let\@xs@toks0\relax}% si commence par 0, ##1 est un «\bgroup»
+					\def\@xs@reserved@A{\def#2{##1}\let\@xs@toks0}% si commence par 0, ##1 est un «\bgroup»
 				\else
 					\def\@xs@reserved@A{\def#2{{##1}}}% si ne commence pas par 0, ##1 est un groupe {...}
 				\fi
@@ -238,7 +238,7 @@
 		\futurelet\@xs@toks\@xs@returnfirstsyntaxunit@i#1\@xs@nil
 	\fi}
 
-% Cette macro interne enlève la 1ere unité syntaxique de #1 et assigne le résultat à #2
+% Cette macro interne enl\`eve la 1ere unit\'e syntaxique de #1 et assigne le r\'esultat \`a #2
 \def\@xs@removefirstsyntaxunit#1#2{%
 	\expandafter\ifx\expandafter\@empty\@xs@beforespace#1 \@xs@nil\@empty
 		\ifx\@empty#1\@empty\def#2{}\else\expandafter\def\expandafter#2\expandafter{\@xs@behindspace#1\@xs@nil}\fi
@@ -246,23 +246,23 @@
 		\expandafter\def\expandafter#2\expandafter{\@xs@gobblefirstchar#1}%
 	\fi}
 
-% Macros à arguments délimités pour les macros ci dessus
+% Macros \`a arguments d\'elimit\'es pour les macros ci dessus
 \def\@xs@beforespace#1 #2\@xs@nil{#1}
 \def\@xs@behindspace#1 #2\@xs@nil{#2}
 \def\@xs@gobblefirstchar#1{}
 \def\@xs@returnfirstsyntaxunit@ii#1#2\@xs@nil{#1}
 
-% Cette macro interne est utilisée dans les macros étoilées pour :
-% 1) développer l'argument selon qu'on a choisit \fullexpandarg
-%    ou \normalexpandarg, et ceci à l'aide de la macro \@xs@def
-% 2) Ensuite, on détokenize ce développement de façon n'avoir plus que
+% Cette macro interne est utilis\'ee dans les macros \'etoil\'ees pour :
+% 1) d\'evelopper l'argument selon qu'on a choisit \fullexpandarg
+%    ou \normalexpandarg, et ceci \`a l'aide de la macro \@xs@def
+% 2) Ensuite, on d\'etokenize ce d\'eveloppement de façon n'avoir plus que
 %    des catcodes de 10 pour les espaces et 12 pour le reste.
 \def\@xs@expand@and@detokenize#1#2{%
 	\def#1{#2}%
-	\expandafter\edef\expandafter#1\expandafter{\@xs@expand#1}% on développe #2 selon le mode de développement
-	\edef#1{\detokenize\expandafter{#1}}}% puis on détokenize et on assigne à #1
+	\expandafter\edef\expandafter#1\expandafter{\@xs@expand#1}% on d\'eveloppe #2 selon le mode de d\'eveloppement
+	\edef#1{\detokenize\expandafter{#1}}}% puis on d\'etokenize et on assigne \`a #1
 
-\def\@xs@expand@and@assign#1#2{\@xs@def#1{#2}}% on développe #2 selon \fullexpandarg ou \normalexpandarg
+\def\@xs@expand@and@assign#1#2{\@xs@def#1{#2}}% on d\'eveloppe #2 selon \fullexpandarg ou \normalexpandarg
 
 \def\@xs@expand@and@addtomacro#1#2{\edef#1{\unexpanded\expandafter{#1}#2}}
 \def\@xs@argstring{0########1########2########3########4########5########6########7########8########9}
@@ -275,160 +275,227 @@
 \def\@xs@OneArg#1{\expandafter\@xs@onearg\expandafter{\number\numexpr#1-1}{#1}}
 \def\@xs@onearg#1#2{\def\@xs@defarg##1#1##2#2##3\@xs@nil{\def\@xs@myarg{##2#2}}\expandafter\@xs@defarg\@xs@argstring\@xs@nil}
 
-\def\@xs@BuildLines#1#2#3{% #1 : numéro du 1er argument; #2 : nombre de lignes; #3 argument optionnel
+% #1 : num\'ero du 1er argument; #2 : nombre de lignes; #3 argument optionnel; #4 : dernier num\'ero de l'argument devant être d\'etokenis\'e si \'etoile
+\def\@xs@BuildLines#1#2#3#4{%
 	\def\@xs@newlines{}%
 	\def\@xs@newargs{}%
 	\def\@xs@buildlines##1{%
 		\expandafter\@xs@OneArg\expandafter{\number\numexpr##1+#1-1}%
-		\@xs@expand@and@addtomacro\@xs@newlines{\noexpand\@xs@assign\expandafter\noexpand\csname @xs@arg@\romannumeral\numexpr##1\endcsname{\@xs@myarg}}%
+		\def\@xs@reserved@B{\noexpand\@xs@expand\csname @xs@arg@\romannumeral\numexpr##1\endcsname}%
 		\ifnum##1=\@ne% si c'est le premier argument
 			\ifx\@empty#3\@empty
-				\@xs@expand@and@addtomacro\@xs@newargs{{\noexpand\@xs@expand\expandafter\noexpand\csname @xs@arg@\romannumeral\numexpr##1\endcsname}}%
+				\@xs@expand@and@addtomacro\@xs@newargs{{\@xs@reserved@B}}%
+				\edef\@xs@reserved@B{\ifnum##1>#4 @xs@def\else @xs@assign\fi}%
 			\else% et s'il y a un argument optionnel alors, on met des crochets
-				\@xs@expand@and@addtomacro\@xs@newargs{[\noexpand\@xs@expand\expandafter\noexpand\csname @xs@arg@\romannumeral\numexpr##1\endcsname]}%
+				\@xs@expand@and@addtomacro\@xs@newargs{[\@xs@reserved@B]}%
+				\def\@xs@reserved@B{@xs@def}% ne pas d\'etok\'eniser l'argument optionnel grace au \@xs@def
 			\fi
 		\else
-			\@xs@expand@and@addtomacro\@xs@newargs{{\noexpand\@xs@expand\expandafter\noexpand\csname @xs@arg@\romannumeral\numexpr##1\endcsname}}%
+			\@xs@expand@and@addtomacro\@xs@newargs{{\@xs@reserved@B}}%
+			\edef\@xs@reserved@B{\ifnum##1>#4 @xs@def\else @xs@assign\fi}%
 		\fi
+		\@xs@expand@and@addtomacro\@xs@newlines{\csname\@xs@reserved@B\endcsname\csname @xs@arg@\romannumeral\numexpr##1\endcsname{\@xs@myarg}}%
 		\ifnum##1<#2\relax
 			\def\@xs@next{\expandafter\@xs@buildlines\expandafter{\number\numexpr##1+1}}%
 			\expandafter\@xs@next
 		\fi}%
 	\@xs@buildlines\@ne}
 
-\def\@xs@newmacro#1#2#3#4#5{%
-% #1 : nom de la macro publique
-% #2 : argument optionnel (vide si pas d'arg optionnel)
-% #3 : nombre d'arguments obligatoires
-% #4 : utilisation de testopt (1 si oui, 0 si non)
-% #5 : code de la macro
-	\edef\@xs@reserved@A{@xs@\expandafter\@xs@gobblefirstchar\string#1}%
-	\edef\@xs@reserved@C{\expandafter\noexpand\csname\@xs@reserved@A @\ifx\@empty#2\@empty @\fi\endcsname}%
+\def\@xs@newmacro{\@ifstar{\let\@xs@reserved@D\@empty\@xs@newmacro@}{\let\@xs@reserved@D\relax\@xs@newmacro@0}}
+% #1 : dernier num\'ero de l'argument devant être d\'etokenis\'e si \'etoile
+% #2 : nom de la macro publique
+% #3 : argument optionnel (vide si pas d'arg optionnel)
+% #4 : nombre d'arguments obligatoires
+% #5 : utilisation de testopt (1 si oui, 0 si non)
+% #6 : code de la macro
+\def\@xs@newmacro@#1#2#3#4#5#6{%
+	\edef\@xs@reserved@A{@xs@\expandafter\@xs@gobblefirstchar\string#2}%
+	\edef\@xs@reserved@C{\csname\@xs@reserved@A @\ifx\@empty#3\@empty @\fi\endcsname}%
 	\edef\@xs@reserved@B{%
-		\def\noexpand#1{\noexpand\@ifstar
+		\ifx\@empty\@xs@reserved@D
+			\def\noexpand#2{\noexpand\@ifstar
 				{\let\noexpand\@xs@assign\noexpand\@xs@expand@and@detokenize\expandafter\noexpand\@xs@reserved@C}%
 				{\let\noexpand\@xs@assign\noexpand\@xs@expand@and@assign\expandafter\noexpand\@xs@reserved@C}}%
-		\ifx\@empty#2\@empty
 		\else
-			\def\expandafter\noexpand\@xs@reserved@C{\noexpand\@ifnextchar[%
-				{\expandafter\noexpand\csname\@xs@reserved@A @@\endcsname}%
-				{\expandafter\noexpand\csname\@xs@reserved@A @@\endcsname[#2]}}%
+			\def\noexpand#2{\let\noexpand\@xs@assign\noexpand\@xs@expand@and@assign\expandafter\noexpand\@xs@reserved@C}%
+		\fi
+		\ifx\@empty#3\@empty
+		\else
+			\def\expandafter\noexpand\@xs@reserved@C{%
+				\noexpand\@testopt{\csname\@xs@reserved@A @@\endcsname}{\ifx\@xs@def\edef#3\else\unexpanded{#3}\fi}}%
 		\fi}%
-	% Que fait \@xs@reserved@B ? Il définit :
-	% si #2 est vide : \NOM{\@ifstar{\let\@xs@assign\@xs@expand@and@detokenize\@xs@NOM@@}{\let\@xs@assign\@xs@expand@and@assign\@xs@NOM@@}}
-	% si #2 existe   : \NOM{\@ifstar{\let\@xs@assign\@xs@expand@and@detokenize\@xs@NOM@}{\let\@xs@assign\@xs@expand@and@assign\@xs@NOM@}}
-	%                  \@xs@NOM@{\@ifnextchar[{\@xs@NOM@@}{\@xs@NOM@@[#2]}}
+	% Que fait \@xs@reserved@B ? Il d\'efinit :
+	% si #3 est vide : \NOM{\@ifstar{\let\@xs@assign\@xs@expand@and@detokenize\@xs@NOM@@}{\let\@xs@assign\@xs@expand@and@assign\@xs@NOM@@}}
+	% si #3 existe   : \NOM{\@ifstar{\let\@xs@assign\@xs@expand@and@detokenize\@xs@NOM@}{\let\@xs@assign\@xs@expand@and@assign\@xs@NOM@}}
+	%                  \@xs@NOM@{\@testopt{\@xs@NOM@@}{#3}}}
 	\@xs@reserved@B
-	\ifx\@empty#2\@empty
-		\@xs@BuildLines1{#3}{#2}%
-		\@xs@DefArg{#3}%
+	\ifx\@empty#3\@empty
+		\@xs@BuildLines1{#4}{#3}{#1}%
+		\@xs@DefArg{#4}%
 	\else
-		\expandafter\@xs@BuildLines\expandafter1\expandafter{\number\numexpr#3+1}{#2}%
-		\@xs@DefArg@{#3}%
+		\expandafter\@xs@BuildLines\expandafter1\expandafter{\number\numexpr#4+1}{#3}{#1}%
+		\@xs@DefArg@{#4}%
 	\fi
-	\edef\@xs@reserved@B{\def\expandafter\noexpand\csname\@xs@reserved@A @@\endcsname\@xs@myarg}%
+	\edef\@xs@reserved@B{\def\csname\@xs@reserved@A @@\endcsname\@xs@myarg}%
 	\edef\@xs@reserved@C{\unexpanded\expandafter{\@xs@newlines}\edef\noexpand\@xs@call}%
-	\edef\@xs@reserved@D{\noexpand\noexpand\expandafter\noexpand\csname\@xs@reserved@A\endcsname\unexpanded\expandafter{\@xs@newargs}}%
-	\ifnum#4=\@ne\edef\@xs@reserved@D{\noexpand\noexpand\noexpand\@testopt{\unexpanded\expandafter{\@xs@reserved@D}}\unexpanded{{}}}\fi
+	\edef\@xs@reserved@D{\noexpand\noexpand\csname\@xs@reserved@A\endcsname\unexpanded\expandafter{\@xs@newargs}}%
+	\ifnum#5=\@ne\edef\@xs@reserved@D{\noexpand\noexpand\noexpand\@testopt{\unexpanded\expandafter{\@xs@reserved@D}}\unexpanded{{}}}\fi
 	\@xs@expand@and@addtomacro\@xs@reserved@C{{\unexpanded\expandafter{\@xs@reserved@D}}\noexpand\@xs@call}%
 	\@xs@expand@and@addtomacro\@xs@reserved@B{{\unexpanded\expandafter{\@xs@reserved@C}}}%
-	% Que fait \@xs@reserved@B ? Il définit par exemple pour 3 arguments obligatoires et 1 facultatif :
-	%    \def\@xs@NOM@@[##1]##2##3##4{%
-	%          \@xs@def\@xs@arg@i{##1}\@xs@assign\@xs@arg@ii{##2}\@xs@assign\@xs@arg@iii{##3}\@xs@asign\@xs@arg@iv{##4}%
-	% si #4=0: \edef\@xs@call{\noexpand\@xs@NOM[\@xs@expand\@xs@arg@i]{\@xs@expand\@xs@arg@ii}{\@xs@expand\@xs@arg@iii}{\@xs@expand\@xs@arg@iv}}%
-	% si #4=1: \edef\@xs@call{\noexpand\@testopt{\noexpand\@xs@NOM[\@xs@expand\@xs@arg@i]{\@xs@expand\@xs@arg@i}{\@xs@expand\@xs@arg@ii}{\@xs@expand\@xs@arg@iii}{\@xs@expand\@xs@arg@iv}}{}}%
+	% Que fait \@xs@reserved@B ? Il d\'efinit par exemple pour 3 arguments obligatoires et 1 facultatif :
+	%    \def\@xs@NOM@@[##2]##3##4##5{%
+	%          \@xs@def\@xs@arg@i{##2}\@xs@assign\@xs@arg@ii{##3}\@xs@assign\@xs@arg@iii{##4}\@xs@asign\@xs@arg@iv{##5}%
+	% si #5=0: \edef\@xs@call{\noexpand\@xs@NOM[\@xs@expand\@xs@arg@i]{\@xs@expand\@xs@arg@ii}{\@xs@expand\@xs@arg@iii}{\@xs@expand\@xs@arg@iv}}%
+	% si #5=1: \edef\@xs@call{\noexpand\@testopt{\noexpand\@xs@NOM[\@xs@expand\@xs@arg@i]{\@xs@expand\@xs@arg@i}{\@xs@expand\@xs@arg@ii}{\@xs@expand\@xs@arg@iii}{\@xs@expand\@xs@arg@iv}}{}}%
 	%          \@xs@call}
 	\@xs@reserved@B
-	\edef\@xs@reserved@B{\def\expandafter\noexpand\csname\@xs@reserved@A\endcsname\@xs@myarg\ifnum#4=\@ne[\unexpanded{##}\number\numexpr\ifx\@empty#2\@empty#3+1\else#3+2\fi]\fi{\unexpanded{#5}}}%
-	% Que fait \@xs@reserved@B ? Il définit par exemple pour 3 arguments obligatoires et 1 facultatif :
-	%    \def \@xs@NOM[##1]##2##3##4[##5]{#5}
+	\edef\@xs@reserved@B{\def\expandafter\noexpand\csname\@xs@reserved@A\endcsname\@xs@myarg\ifnum#5=\@ne[\unexpanded{##}\number\numexpr\ifx\@empty#3\@empty#4+1\else#4+2\fi]\fi{\unexpanded{#6}}}%
+	% Que fait \@xs@reserved@B ? Il d\'efinit par exemple pour 3 arguments obligatoires et 1 facultatif :
+	%    \def \@xs@NOM[##2]##3##4##5[##6]{#6}
 	\@xs@reserved@B}
 
-\@xs@newmacro\StrRemoveBraces{}{1}{1}{%
-	\let\@xs@reserved@C\@empty
-	\def\@xs@reserved@A{#1}%
-	\@xs@StrRemoveBraces@i
-	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#2}}
-\def\@xs@StrRemoveBraces@i{%
-	\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@A}\@xs@reserved@B
-	\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@A}\@xs@reserved@A
-	\ifx\bgroup\@xs@toks
-		\ifx\@xs@exploregroups\@empty% on explore les groupes ?
+% macro g\'en\'erique qui lit \@xs@reserved@C lex\`eme par lex\`eme
+% 3 sous-routines sont appel\'ees \`a des moments cl\'e :
+% \@xs@atendofgroup      (un groupe se finit, appel r\'ecursif)
+% \@xs@atbegingroup      (un groupe vient d'être ouvert)
+% \@xs@atnextsyntaxunit  (la future US n'est pas un groupe)
+\def\@xs@read@reserved@C{%
+	\ifx\@xs@reserved@C\@empty
+		\ifnum\@xs@nestlevel=\z@
+			\let\@xs@next\relax
+		\else
+			\let\@xs@next\@xs@atendofgroup
+		\fi
+	\else
+		\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@A
+		\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C
+		\let\@xs@next\@xs@read@reserved@C
+		\@xs@exploregroups
+		\ifx\bgroup\@xs@toks
+			\advance\integerpart\@ne
 			\begingroup
-				\let\@xs@reserved@C\@empty
-				\expandafter\def\expandafter\@xs@reserved@A\@xs@reserved@B
-				\@xs@StrRemoveBraces@i
-				\expandafter
-			\endgroup
-			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\@xs@reserved@C}%
+				\expandafter\def\expandafter\@xs@reserved@C\@xs@reserved@A
+				\@xs@manage@groupID
+				\let\@xs@nestlevel\@ne
+				\integerpart\z@
+				\@xs@atbegingroup
 		\else
-			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\@xs@reserved@B
+			\global\advance\@xs@count\@ne
+			\@xs@atnextsyntaxunit
+		\fi
+	\fi
+	\@xs@next}
+
+% macro g\'en\'erique qui lit \@xs@reserved@D en proc\'edant \`a des tests avec \IfBeginWith
+% 2 sous-routines sont appel\'ees \`a des moments cl\'e :
+% \@xs@atendofgroup      (un groupe se finit, appel r\'ecursif)
+% \@xs@atoccurfound      (une occurrence a \'et\'e trouv\'ee)
+\def\@xs@read@reserved@D{%
+	\ifx\@xs@reserved@D\@empty
+		\ifnum\@xs@nestlevel=\z@
+			\let\@xs@next\relax
+		\else
+			\let\@xs@next\@xs@atendofgroup
 		\fi
 	\else
-		\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\@xs@reserved@B}%
+		\expandafter\expandafter\expandafter\@xs@IfBeginWith@i\expandafter\expandafter\expandafter{\expandafter\@xs@reserved@D\expandafter}\expandafter{\@xs@reserved@E}%
+		{\global\advance\@xs@count\@ne
+		 \let\@xs@reserved@D\@xs@reserved@A
+		 \@xs@atoccurfound}%
+		{\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@D}\@xs@reserved@A
+		 \expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@D}\@xs@reserved@D
+		 \let\@xs@next\@xs@read@reserved@D
+		 \@xs@exploregroups
+		 \ifx\bgroup\@xs@toks
+		 	\advance\integerpart\@ne
+		 	\begingroup
+		 		\expandafter\def\expandafter\@xs@reserved@D\@xs@reserved@A
+				\@xs@manage@groupID
+		 		\let\@xs@reserved@C\@empty
+		 		\let\@xs@nestlevel\@ne
+		 		\integerpart\z@
+		 \else
+		 	\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\@xs@reserved@A}%
+		 \fi}%
 	\fi
-	\expandafter\let\expandafter\@xs@next\ifx\@empty\@xs@reserved@A\relax\else\@xs@StrRemoveBraces@i\fi
-	\@xs@next}%
+	\@xs@next}
 
-\def\@xs@strip@delimit#1\@delimit#2\@xs@nil{#1}
-% \@xs@cutafteroccur coupe l'argument #1 après la #3ème occurrence de #2
-% #4 : contient ce qui se trouve avant cette occurrence y compris l'occurrence
-% #5 : idem mais sans l'occurrence
-% #6 : contient ce qui se trouve après l'occurrence
-% si l'occurrence n'existe pas ou qu'un des arguments est vide, toutes les chaines renvoyées sont vides
-% utilise \@xs@reserved@A -> \@xs@reserved@B
-\def\@xs@cutafteroccur#1#2#3#4#5#6{%
-	\def\@xs@cutafteroccur@i{%
-		\ifx#6\@empty% on a fini de parcourir #6 ?
-			\let\@xs@next\relax% on sort de la macro
+\@xs@newmacro\StrRemoveBraces{}{1}{1}{%
+	\def\@xs@reserved@C{#1}%
+	\let\@xs@reserved@B\@empty
+	\let\@xs@nestlevel\z@
+	\@xs@StrRemoveBraces@i
+	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@B}{#2}}
+\def\@xs@StrRemoveBraces@i{%
+	\let\@xs@next\@xs@StrRemoveBraces@i
+	\ifx\@xs@reserved@C\@empty
+		\ifnum\@xs@nestlevel=\z@
+			\let\@xs@next\relax
 		\else
-			\expandafter\@xs@IfBeginWith@i\expandafter{#6}{#2}%
-				{\global\advance\@xs@count\@ne
-				 \ifnum\@xs@count<#3\relax\@xs@addtomacro#5{#2}\@xs@gaddtomacro\@xs@beforeoccur{#2}\fi
-				 \let#6\@xs@reserved@A}% on enlève le motif à #6
-				{\expandafter\@xs@returnfirstsyntaxunit\expandafter{#6}\@xs@reserved@A% #6 ne commence pas par le motif : on prend la 1ere unité syntaxique
-				 \expandafter\@xs@removefirstsyntaxunit\expandafter{#6}#6% puis on l'enlève
-				 \@xs@exploregroups
-				 \ifx\bgroup\@xs@toks% si cette unité syntaxique est un groupe {...}
-				 	\begingroup% alors on ouvre un groupe
-				 		\expandafter\def\expandafter#6\@xs@reserved@A%
-				 		\let#4\@empty\let#5\@empty% on initialise dans ce nouveau groupe
-				 		\@xs@cutafteroccur@i% puis une récursivité
-				 		\ifx#4\@empty% si l'occurrence n'est pas trouvée dans ce groupe
-							\def\@xs@next{% on en sort après avoir rajouté à #5 du groupe de niveau au dessus le #5 de ce groupe
-				 				\expandafter\endgroup
-				 				\expandafter\@xs@addtomacro\expandafter#5\expandafter{\expandafter{#5}}}%
-				 		\else
-							\let\@xs@next\endgroup% sinon, on sort du groupe
-				 		\fi
-				 		\@xs@next
-				 \else
-				 	\expandafter\@xs@gaddtomacro\expandafter\@xs@beforeoccur\expandafter{\@xs@reserved@A}%
-				 	\expandafter\@xs@addtomacro\expandafter#5\expandafter{\@xs@reserved@A}%
-				 \fi}%
-			\ifnum\@xs@count=#3\relax% l'occurrence est atteinte...
-				\global\let#5#5\global\let#6#6% on passe à la globalité si jamais on est dans un groupe
-				\expandafter\gdef\expandafter#4\expandafter{#5#2}% on rajoute le pattern à #5
-				\let\@xs@next\relax% et on sort de la macro
+			\expandafter\endgroup
+			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@B\expandafter{\@xs@reserved@B}%
+		\fi
+	\else
+		\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@A
+		\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C
+		\ifx\bgroup\@xs@toks
+			\ifx\@xs@exploregroups\relax% on explore les groupes ?
+				\begingroup
+					\expandafter\def\expandafter\@xs@reserved@C\@xs@reserved@A
+					\let\@xs@nestlevel\@ne
+					\integerpart\z@
+					\let\@xs@reserved@B\@empty
 			\else
-				\let\@xs@next\@xs@cutafteroccur@i%
+				\expandafter\@xs@addtomacro\expandafter\@xs@reserved@B\@xs@reserved@A
 			\fi
+		\else
+			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@B\expandafter{\@xs@reserved@A}%
 		\fi
-		\@xs@next}%
-	\let#4\@empty\let#5\@empty\def#6{#1}\let\@xs@beforeoccur\@empty\@xs@count\z@
- \@xs@cutafteroccur@i
-	\ifx\@empty#4\let#5#4\let#6#4\fi}% occurrence pas trouvée
+	\fi
+	\@xs@next}
 
-% utilise \@xs@reserved@A -> \@xs@reserved@D
-\@xs@newmacro\IfSubStr{1}{2}{0}{%
-	\@xs@cutafteroccur{#2}{#3}{#1}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
-	\ifx\@xs@reserved@C\@empty
+\def\@xs@strip@delimit#1\@delimit#2\@xs@nil{#1}
+
+% \@xs@cutafteroccur coupe l'argument #1 apr\`es la #3\`eme occurrence de #2
+% \@xs@reserved@C : contient ce qui se trouve avant cette occurrence
+% \@xs@reserved@D : contient ce qui se trouve avant cette occurrence y compris cette occurrence
+% \@xs@reserved@E : contient ce qui se trouve apr\`es l'occurrence
+% si l'occurrence n'existe pas ou qu'un des arguments est vide, toutes les chaines renvoy\'ees sont vides
+\def\@xs@cutafteroccur#1#2#3{%
+	\def\@xs@reserved@D{#1}\let\@xs@reserved@C\@empty\def\@xs@reserved@E{#2}%
+	\@xs@count\z@\integerpart\z@\decimalpart#3\def\groupID{0}\let\@xs@nestlevel\z@
+	\def\@xs@atendofgroup{%
+		\expandafter\endgroup
+		\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\expandafter{\@xs@reserved@C}}%
+		\@xs@read@reserved@D}%
+	\def\@xs@atoccurfound{%
+		\ifnum\@xs@count=\decimalpart
+			\global\let\@xs@reserved@D\@xs@reserved@D
+			\global\let\@xs@reserved@C\@xs@reserved@C
+			\global\let\groupID\groupID
+			\@xs@exitallgroups
+			\let\@xs@next\relax
+		\else
+			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\@xs@reserved@E}%
+			\let\@xs@next\@xs@read@reserved@D
+		\fi}%
+	\@xs@read@reserved@D
+	\ifnum\@xs@count=\decimalpart% occurrence trouv\'ee ?
+		\let\@xs@reserved@E\@xs@reserved@D
+		\expandafter\def\expandafter\@xs@reserved@D\expandafter{\@xs@reserved@C#2}%
+	\else
+		\let\@xs@reserved@C\@empty\let\@xs@reserved@E\@empty\let\groupID\@empty
+	\fi}
+
+\@xs@newmacro*3\IfSubStr{1}{2}{0}{%
+	\@xs@cutafteroccur{#2}{#3}{#1}%
+	\ifx\@xs@reserved@D\@empty
 		\expandafter\@secondoftwo
 	\else
 		\expandafter\@firstoftwo
 	\fi}
 
-\@xs@newmacro\IfBeginWith{}{2}{0}{%
+\@xs@newmacro*2\IfBeginWith{}{2}{0}{%
 	\ifx\@empty#2\@empty
 		\let\@xs@next\@secondoftwo
 	\else
@@ -436,7 +503,7 @@
 	\fi
 	\@xs@next}
 \def\@xs@IfBeginWith@i#1#2{%
-	\ifx\@empty#2\@empty% #2 est vide, tous les tests sont passés avec succès : on renvoie #3
+	\ifx\@empty#2\@empty% #2 est vide, tous les tests sont pass\'es avec succ\`es : on renvoie #3
 		\let\@xs@next\@firstoftwo
 	\else
 		\ifx\@empty#1\@empty
@@ -444,8 +511,8 @@
 		\else
 			\@xs@returnfirstsyntaxunit{#1}\@xs@reserved@A
 			\@xs@returnfirstsyntaxunit{#2}\@xs@reserved@B
-			\ifx\@xs@reserved@A\@xs@reserved@B% il y a égalité...
-				\@xs@removefirstsyntaxunit{#1}\@xs@reserved@A% on enlève les 1ere unités syntaxiques
+			\ifx\@xs@reserved@A\@xs@reserved@B% il y a \'egalit\'e...
+				\@xs@removefirstsyntaxunit{#1}\@xs@reserved@A% on enl\`eve les 1ere unit\'es syntaxiques
 				\@xs@removefirstsyntaxunit{#2}\@xs@reserved@B
 				\def\@xs@next{% et on recommence avec ces arguments racourcis d'1 token
 					\expandafter\expandafter\expandafter\@xs@IfBeginWith@i
@@ -457,31 +524,36 @@
 	\fi
 	\@xs@next}
 
-\@xs@newmacro\IfEndWith{}{2}{0}{%
-	\@xs@StrCount{#1}{#2}[\@xs@reserved@A]%
-	\ifnum\@xs@reserved@A=\z@
-		\let\@xs@reserved@A\@secondoftwo%
+\@xs@newmacro*2\IfEndWith{}{2}{0}{%
+	\ifx\@empty#2\@empty
+		\let\@xs@reserved@A\@secondoftwo
 	\else
-		\ifx\@empty\@xs@StrCount@afterlastocccur
-			\let\@xs@reserved@A\@firstoftwo%
+		\@xs@StrCount{#1}{#2}[\@xs@reserved@A]%
+		\ifnum\@xs@reserved@A=\z@
+			\let\@xs@reserved@A\@secondoftwo
 		\else
-			\let\@xs@reserved@A\@secondoftwo%
+			\ifx\@xs@reserved@C\@empty
+				\let\@xs@reserved@A\@firstoftwo
+			\else
+				\let\@xs@reserved@A\@secondoftwo
+			\fi
 		\fi
 	\fi
 	\@xs@reserved@A}
 
-\@xs@newmacro\IfSubStrBefore{1,1}{3}{0}{\@xs@IfSubStrBefore@i[#1]{#2}{#3}{#4}}
+\@xs@newmacro*4\IfSubStrBefore{1,1}{3}{0}{\@xs@IfSubStrBefore@i[#1]{#2}{#3}{#4}}
 \def\@xs@IfSubStrBefore@i[#1,#2]#3#4#5{%
-	\ifx\@xs@exploregroups\@empty\let\@xs@reserved@C\@empty\def\@xs@reserved@A{#3}\@xs@StrRemoveBraces@i\else\def\@xs@reserved@C{#3}\fi
-	\expandafter\@xs@cutafteroccur\expandafter{\@xs@reserved@C}{#5}{#2}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
-	\expandafter\@xs@cutafteroccur\expandafter{\@xs@reserved@D}{#4}{#1}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
+	\ifx\@xs@exploregroups\relax\let\@xs@reserved@C\@empty\def\@xs@reserved@A{#3}\@xs@StrRemoveBraces@i\else\def\@xs@reserved@C{#3}\fi
+	\expandafter\@xs@cutafteroccur\expandafter{\@xs@reserved@C}{#5}{#2}%
+	\expandafter\@xs@cutafteroccur\expandafter{\@xs@reserved@C}{#4}{#1}%
+	\let\groupID\@empty
 	\ifx\@xs@reserved@C\@empty
 		\expandafter\@secondoftwo
 	\else
 		\expandafter\@firstoftwo
 	\fi}
 
-\@xs@newmacro\IfSubStrBehind{1,1}{3}{0}{\@xs@IfSubStrBehind@i[#1]{#2}{#3}{#4}}
+\@xs@newmacro*4\IfSubStrBehind{1,1}{3}{0}{\@xs@IfSubStrBehind@i[#1]{#2}{#3}{#4}}
 \def\@xs@IfSubStrBehind@i[#1,#2]#3#4#5{\@xs@IfSubStrBefore@i[#2,#1]{#3}{#5}{#4}}
 
 \def\@xs@formatnumber#1#2{%
@@ -544,28 +616,28 @@
 	\expandafter\@xs@endnumber\@xs@afterinteger\@xs@nil}
 \def\@xs@endnumber#1\@xs@nil{\def\@xs@afterdecimal{#1}}
 
-% test d'égalité sur des chaines (et des chaines contenant des nombres)
+% test d'\'egalit\'e sur des chaines (et des chaines contenant des nombres)
 \def\@xs@IfStrEqFalse@i#1#2{\let\@xs@reserved@A\@secondoftwo}
-\def\@xs@IfStrEqFalse@ii#1#2{% renvoie vrai si les 2 arg sont décimaux et s'ils sont égaux, faux sinon
+\def\@xs@IfStrEqFalse@ii#1#2{% renvoie vrai si les 2 arg sont d\'ecimaux et s'ils sont \'egaux, faux sinon
 	\@xs@IfDecimal{#1}%
 		{\@xs@IfDecimal{#2}%
-			{\ifdim#1pt=#2pt\let\@xs@reserved@A\@firstoftwo\else\let\@xs@reserved@A\@secondoftwo\fi}% les 2 sont décimaux : on fait le test
-			{\let\@xs@reserved@A\@secondoftwo}}% un seul est décimal
-		{\let\@xs@reserved@A\@secondoftwo}}% #1 n'est pas décimal
+			{\ifdim#1pt=#2pt\let\@xs@reserved@A\@firstoftwo\else\let\@xs@reserved@A\@secondoftwo\fi}% les 2 sont d\'ecimaux : on fait le test
+			{\let\@xs@reserved@A\@secondoftwo}}% un seul est d\'ecimal
+		{\let\@xs@reserved@A\@secondoftwo}}% #1 n'est pas d\'ecimal
 
-\def\@xs@TestEqual#1#2{% teste si les 2 arguments sont égaux
+\def\@xs@TestEqual#1#2{% teste si les 2 arguments sont \'egaux
 	\def\@xs@reserved@A{#1}\def\@xs@reserved@B{#2}%
 	\ifx\@xs@reserved@A\@xs@reserved@B
-		\let\@xs@reserved@A\@firstoftwo% égalité parfaite des 2 chaines
+		\let\@xs@reserved@A\@firstoftwo% \'egalit\'e parfaite des 2 chaines
 	\else
 		\@xs@reserved@D{#1}{#2}%
 	\fi
 	\@xs@reserved@A}
 
-\@xs@newmacro\IfStrEq{}{2}{0}{% teste si les deux chaines sont égales
+\@xs@newmacro*2\IfStrEq{}{2}{0}{% teste si les deux chaines sont \'egales
 	\let\@xs@reserved@D\@xs@IfStrEqFalse@i
 	\@xs@TestEqual{#1}{#2}}
-\@xs@newmacro\IfEq{}{2}{0}{% teste si les 2 arguments (chaine ou nombre) sont égaux
+\@xs@newmacro*2\IfEq{}{2}{0}{% teste si les 2 arguments (chaine ou nombre) sont \'egaux
 	\let\@xs@reserved@D\@xs@IfStrEqFalse@ii
 	\@xs@TestEqual{#1}{#2}}
 
@@ -576,259 +648,227 @@
 \def\@xs@IfEqCase#1#2{\@testopt{\@xs@IfStringCase{#1}{#2}}{}}
 
 \def\@xs@IfStringCase#1#2[#3]{%
-	\def\@xs@testcase##1##2##3\@xs@nil{% lit les 2 premieres unités syntaxiques dans ##1 et ##2. Les autres dans ##3
+	\def\@xs@testcase##1##2##3\@xs@nil{% lit les 2 premieres unit\'es syntaxiques dans ##1 et ##2. Les autres dans ##3
 		\@xs@reserved@E{#1}{##1}%
-			{##2}% le test est positif, on exécute le code correspondant
-			{\ifx\@empty##3\@empty% le test est négatif
-			 	\def\@xs@next{#3}% s'il n'y a plus de cas, on exécute le code <autres cas>
+			{##2}% le test est positif, on ex\'ecute le code correspondant
+			{\ifx\@empty##3\@empty% le test est n\'egatif
+			 	\def\@xs@next{#3}% s'il n'y a plus de cas, on ex\'ecute le code <autres cas>
 			 \else
 			 	\def\@xs@next{\@xs@testcase##3\@xs@nil}% sinon, on recommence avec ce qui reste
 			 \fi
 			 \@xs@next}}%
 	\@xs@testcase#2\@xs@nil}
 
+% Renvoie ce qui est \`a gauche de l'occurence n°#1 de la sous chaine #3 dans la chaine
+\@xs@newmacro*3\StrBefore{1}{2}{1}{%
+	\@xs@cutafteroccur{#2}{#3}{#1}%
+	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#4}}
 
-% Renvoie ce qui est à gauche de l'occurence n°#1 de la sous chaine #3 dans la chaine
-\@xs@newmacro\StrBefore{1}{2}{1}{%
-	\@xs@cutafteroccur{#2}{#3}{#1}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
-	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@D}{#4}}
-
-% Renvoie ce qui est à droite de l'occurence n°#1 de la sous chaine #3 dans la chaine #2
-\@xs@newmacro\StrBehind{1}{2}{1}{%
-	\@xs@cutafteroccur{#2}{#3}{#1}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
+% Renvoie ce qui est \`a droite de l'occurence n°#1 de la sous chaine #3 dans la chaine #2
+\@xs@newmacro*3\StrBehind{1}{2}{1}{%
+	\@xs@cutafteroccur{#2}{#3}{#1}%
 	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@E}{#4}}
 
 % Renvoie ce qui est strictement compris entre les occurrences n°#1 et n°#2
 % des chaines #4 et #5 dans la chaine #3
-\@xs@newmacro\StrBetween{1,1}{3}{1}{\@xs@StrBetween@i[#1]{#2}{#3}{#4}[#5]}
+\@xs@newmacro*4\StrBetween{1,1}{3}{1}{\@xs@StrBetween@i[#1]{#2}{#3}{#4}[#5]}
 \def\@xs@StrBetween@i[#1,#2]#3#4#5[#6]{%
 	\begingroup
 		\noexploregroups
-		\@xs@cutafteroccur{#3}{#5}{#2}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
-		\expandafter\@xs@cutafteroccur\expandafter{\@xs@reserved@D}{#4}{#1}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
+		\@xs@cutafteroccur{#3}{#5}{#2}%
+		\expandafter\@xs@cutafteroccur\expandafter{\@xs@reserved@C}{#4}{#1}%
 		\expandafter
 	\endgroup
-	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@E}{#6}}
+	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@E}{#6}%
+	\let\groupID\@empty}
 
 \def\@xs@addtomacro#1#2{\expandafter\def\expandafter#1\expandafter{#1#2}}
-\def\@xs@gaddtomacro#1#2{\expandafter\gdef\expandafter#1\expandafter{#1#2}}
-\def\exploregroups{\def\@xs@exploregroups{}}
+
+\def\exploregroups{\let\@xs@exploregroups\relax}
 \def\noexploregroups{\def\@xs@exploregroups{\let\@xs@toks0\relax}}
 \def\saveexploremode{\let\@xs@saveexploremode\@xs@exploregroups}
 \def\restoreexploremode{\let\@xs@exploregroups\@xs@saveexploremode}
-% Remplace les #1 premières occurences de la chaine #3
+
+% Remplace les #1 premi\`eres occurences de la chaine #3
 % par la chaine #4 dans la chaine #2
-% utilise \@xs@reserved@A -> \@xs@reserved@E
 \@xs@newmacro\StrSubstitute{0}{3}{1}{%
-	\ifx\@empty#3\@empty% si #4 est vide, on ne fait rien
-		\@xs@ArgEmpty% warning
-		\@xs@ReturnResult{#2}{#5}%
-	\else
-		\@xs@StrSubstitute@i[#1]{#2}{#3}{#4}{#5}%
-	\fi}%
-\def\@xs@StrSubstitute@i[#1]#2#3#4#5{%
-	\def\@xs@StrSubstitute@ii{%
-		\ifx\@xs@reserved@C\@empty% on a fini de parcourir \@xs@reserved@C ?
-			\let\@xs@next\relax% on sort de la macro
+	\def\@xs@reserved@D{#2}\let\@xs@reserved@C\@empty\def\@xs@reserved@E{#3}%
+	\@xs@count\z@\integerpart\z@\def\groupID{0}\let\@xs@nestlevel\z@
+	\def\@xs@atendofgroup{%
+		\expandafter\endgroup
+		\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\expandafter{\@xs@reserved@C}}%
+		\@xs@read@reserved@D}%
+	\def\@xs@atoccurfound{%
+		\ifnum#1=\z@
+			\def\@xs@reserved@A{#4}%
 		\else
-			\ifnum\@xs@count=#1\relax
-				\expandafter\@xs@addtomacro\expandafter\@xs@reserved@D\expandafter{\@xs@reserved@C}%
-				\let\@xs@next\relax
+			\ifnum\@xs@count>#1
+				\def\@xs@reserved@A{#3}%
 			\else
-				\expandafter\@xs@IfBeginWith@i\expandafter{\@xs@reserved@C}{#3}%
-					{\@xs@addtomacro\@xs@reserved@D{#4}% \@xs@reserved@C commence par le motif --> on substitue
-					 \global\advance\@xs@count\@ne
-					 \let\@xs@reserved@C\@xs@reserved@A}% on enlève le motif à \@xs@reserved@C
-					{\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@A% \@xs@reserved@C ne commence pas par le motif : on prend la 1ere unité syntaxique
-					 \expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C% puis on l'enlève
-					 \@xs@exploregroups
-					 \ifx\bgroup\@xs@toks% si cette unité syntaxique est un groupe {...}
-					 	\begingroup% alors on ouvre un groupe
-					 		\expandafter\def\expandafter\@xs@reserved@C\@xs@reserved@A% \@xs@reserved@C devient l'intérieur de {...}
-					 		\let\@xs@reserved@D\@empty% #4 est initialisé à vide dans ce nouveau groupe
-					 		\@xs@StrSubstitute@ii% on lance la macro avec ces nouvelles définitions
-					 		\expandafter% on retarde la fermeture du groupe
-					 	\endgroup% pour ajouter \@xs@reserved@D de ce groupe au \@xs@reserved@D du groupe supérieur
-					 	\expandafter\@xs@addtomacro\expandafter\@xs@reserved@D\expandafter{\expandafter{\@xs@reserved@D}}%
-					 \else
-					 	\expandafter\@xs@addtomacro\expandafter\@xs@reserved@D\expandafter{\@xs@reserved@A}%
-					 \fi}%
-				\let\@xs@next\@xs@StrSubstitute@ii%
+				\def\@xs@reserved@A{#4}%
 			\fi
 		\fi
-		\@xs@next}%
-	\def\@xs@reserved@D{}\def\@xs@reserved@C{#2}%
-	\@xs@count\ifnum#1>\z@\z@\else\@ne\fi
-	\@xs@StrSubstitute@ii
-	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@D}{#5}}
+		\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\@xs@reserved@A}%
+		\@xs@read@reserved@D}%
+	\ifx\@empty#3\@empty
+		\@xs@ReturnResult{#2}{#5}%
+	\else
+		\@xs@read@reserved@D
+		\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#5}%
+	\fi}
 
-% Supprime les #1 premières occurrences de #3 dans #2
+% Supprime les #1 premi\`eres occurrences de #3 dans #2
 \@xs@newmacro\StrDel{0}{2}{1}{\@xs@StrSubstitute[#1]{#2}{#3}{}[#4]}
 
-% Compte combien d'unités syntaxiques contient la chaine #1 ?
+\def\@xs@exitallgroups{\ifnum\@xs@nestlevel>\z@\endgroup\expandafter\@xs@exitallgroups\fi}
+
+% Compte combien d'unit\'es syntaxiques contient la chaine #1 ?
 \@xs@newmacro\StrLen{}{1}{1}{%
 	\def\@xs@reserved@C{#1}%
 	\@xs@count\z@
-	\@xs@StrLen@i
+	\let\@xs@nestlevel\z@
+	\def\groupID{0}%
+	\let\@xs@atbegingroup\relax
+	\def\@xs@atendofgroup{\endgroup\@xs@read@reserved@C}%
+	\let\@xs@atnextsyntaxunit\relax
+	\@xs@read@reserved@C
 	\expandafter\@xs@ReturnResult\expandafter{\number\@xs@count}{#2}}
-\def\@xs@StrLen@i{%
+
+% Macro interne fermant autant de groupes que n\'ecessaire pour trouver une unit\'e syntaxique derri\`ere
+\def\@xs@continuetonext{%
 	\ifx\@xs@reserved@C\@empty
+		\ifnum\@xs@nestlevel>\z@
+			\expandafter\endgroup\expandafter\@xs@addtomacro\expandafter\@xs@reserved@B\expandafter{\expandafter{\@xs@reserved@B}}% on concat\`ene
+			\expandafter\expandafter\expandafter\@xs@continuetonext% on recommence
+		\fi
+	\fi}%
+
+\def\@xs@manage@groupID{%
+	\begingroup\def\@xs@reserved@A{0}%
+	\ifx\@xs@reserved@A\groupID% si on arrive du groupe de niveau 0
+		\endgroup\edef\groupID{\number\integerpart}% on met simplement le niveau
 	\else
-		\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@A
-		\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C
-		\@xs@exploregroups
-		\ifx\bgroup\@xs@toks
-			\begingroup
-				\expandafter\def\expandafter\@xs@reserved@C\@xs@reserved@A
-				\@xs@StrLen@i
-			\endgroup
-		\else
-			\global\advance\@xs@count\@ne
-		\fi%
-		\expandafter\@xs@StrLen@i
+		\endgroup\expandafter\@xs@addtomacro\expandafter\groupID\expandafter{\expandafter,\number\integerpart}%
 	\fi}
 
-% % Cette macro coupe la chaine #2 après l'unité syntaxique n°#1
-% % Le début est assigné dans #3 et la fin dans #4
-\@xs@newmacro\StrSplit{}{2}{0}{\@xs@StrSplit@i{#2}{#1}}
-\def\@xs@StrSplit@i#1#2#3#4{%
-	\def\@xs@StrSplit@ii{%
-		\ifx#4\@empty
-			\let\@xs@next\relax
-		\else
-			\expandafter\@xs@returnfirstsyntaxunit\expandafter{#4}\@xs@reserved@A
-			\expandafter\@xs@removefirstsyntaxunit\expandafter{#4}#4%
-			\@xs@exploregroups
-			\ifx\bgroup\@xs@toks
-				\begingroup
-					\expandafter\def\expandafter#4\@xs@reserved@A
-					\let#3\@empty
-					\@xs@StrSplit@ii
-					\ifx#4\@empty
-						\def\@xs@next{%
-							\expandafter\endgroup
-							\expandafter\@xs@addtomacro\expandafter#3\expandafter{\expandafter{#3}}}%
-					\else
-						\let\@xs@next\endgroup
-					\fi
-				\@xs@next
-			\else
-				\global\advance\@xs@count\@ne
-				\expandafter\@xs@addtomacro\expandafter#3\expandafter{\@xs@reserved@A}%
-			\fi
-			\ifnum\@xs@count=#1\relax
-				\global\let#3#3\global\let#4#4%
-				\let\@xs@next\relax
-			\else
-				\let\@xs@next\@xs@StrSplit@ii
-			\fi
-		\fi
-		\@xs@next}%
-	\def#4{#2}\let#3\@empty
+% Cette macro coupe la chaine #1 apr\`es l'unit\'e syntaxique n°#2
+\def\StrSplit{\@ifstar{\let\@xs@reserved@E\@xs@continuetonext\StrSpl@t}{\let\@xs@reserved@E\relax\StrSpl@t}}
+\@xs@newmacro\StrSpl@t{}{2}{0}{\@xs@StrSplit@i{#2}{#1}\@xs@StrSplit@ii}
+% Cette macro interne coupe la chaine #2 apr\`es l'unit\'e syntaxique n°#1
+% Le d\'ebut est assign\'e dans \@xs@reserved@B et la fin dans \@xs@reserved@C
+\def\@xs@StrSplit@i#1#2{%
+	\def\@xs@reserved@D{#1}\def\@xs@reserved@C{#2}\let\@xs@reserved@B\@empty\let\groupID\@empty
 	\ifnum#1>\z@
-		\@xs@count\z@
-		\@xs@StrSplit@ii
+		\@xs@count\z@\integerpart\z@\def\groupID{0}\let\@xs@nestlevel\z@
+		\def\@xs@atendofgroup{%
+			\expandafter\endgroup
+			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@B\expandafter{\expandafter{\@xs@reserved@B}}%
+			\@xs@read@reserved@C}%
+		\def\@xs@atbegingroup{\let\@xs@reserved@B\@empty}%
+		\def\@xs@atnextsyntaxunit{%
+			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@B\expandafter{\@xs@reserved@A}%
+			\ifnum\@xs@count=\@xs@reserved@D\relax
+				\ifx\@xs@reserved@C\@empty\@xs@reserved@E\fi
+				\global\let\@xs@reserved@B\@xs@reserved@B
+				\global\let\@xs@reserved@C\@xs@reserved@C
+				\global\let\groupID\groupID
+				\@xs@exitallgroups
+				\let\@xs@next\relax
+			\fi}%
+		\@xs@read@reserved@C
 	\fi}
+\def\@xs@StrSplit@ii#1#2{\let#1\@xs@reserved@B\let#2\@xs@reserved@C}
 
 % De la chaine #1, renvoie ce qui se trouve entre les positions
-%  #2 et #3, caractères aux positions compris !
+%  #2 et #3, unit\'es syntaxiques aux positions compris !
 \@xs@newmacro\StrMid{}{3}{1}{%
 	\begingroup
 		\noexploregroups
-		\@xs@StrSplit{#1}{#3}\@xs@reserved@B\@xs@reserved@C
-		\expandafter\expandafter\expandafter\@xs@StrSplit\expandafter\expandafter\expandafter{\expandafter\@xs@reserved@B\expandafter}\expandafter{\number\numexpr#2-1}\@xs@reserved@B\@xs@reserved@C
+		\@xs@StrSplit@i{#3}{#1}%
+		\edef\@xs@reserved@C{\number\numexpr#2-1}%
+		\expandafter\expandafter\expandafter\@xs@StrSplit@i\expandafter\expandafter\expandafter{\expandafter\@xs@reserved@C\expandafter}\expandafter{\@xs@reserved@B}%
 	\expandafter\endgroup
-	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#4}}
+	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#4}%
+	\let\groupID\@empty}
 
-% supprime #2 caractères à gauche dans la chaine #1
+% supprime #2 unit\'es syntaxiques \`a gauche dans la chaine #1
 \@xs@newmacro\StrGobbleLeft{}{2}{1}{%
-	\@xs@StrSplit@i{#2}{#1}\@xs@reserved@B\@xs@reserved@C
+	\@xs@StrSplit@i{#2}{#1}%
 	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#3}}
 
-% extrait de #1 la chaine à gauche de longueur #2
+% extrait de #1 la chaine \`a gauche de longueur #2
 \@xs@newmacro\StrLeft{}{2}{1}{%
-	\@xs@StrSplit@i{#2}{#1}\@xs@reserved@B\@xs@reserved@C
+	\@xs@StrSplit@i{#2}{#1}%
 	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@B}{#3}}
 
-% supprime #2 caractères à droite dans la chaine #1
+% supprime #2 unit\'es syntaxiques \`a droite dans la chaine #1
 \@xs@newmacro\StrGobbleRight{}{2}{1}{%
 	\@xs@StrLen{#1}[\@xs@reserved@E]%
-	\expandafter\@xs@StrSplit@i\expandafter{\number\numexpr\@xs@reserved@E-#2}{#1}\@xs@reserved@C\@xs@reserved@D
-	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#3}}
+	\expandafter\@xs@StrSplit@i\expandafter{\number\numexpr\@xs@reserved@E-#2}{#1}%
+	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@B}{#3}}
 
-% renvoie #2 caractères à la droite de la chaine #1
+% renvoie #2 unit\'es syntaxiques \`a la droite de la chaine #1
 \@xs@newmacro\StrRight{}{2}{1}{%
 	\@xs@StrLen{#1}[\@xs@reserved@E]%
-	\expandafter\@xs@StrSplit@i\expandafter{\number\numexpr\@xs@reserved@E-#2}{#1}\@xs@reserved@C\@xs@reserved@D
-	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@D}{#3}}
+	\expandafter\@xs@StrSplit@i\expandafter{\number\numexpr\@xs@reserved@E-#2}{#1}%
+	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#3}}
 
 \@xs@newmacro\StrChar{}{2}{1}{%
-	\ifnum#2<\@ne
-		\@xs@ReturnResult{}{#3}%
-	\else
-		\expandafter\@xs@StrSplit@i\expandafter{\number\numexpr#2-1}{#1}\@xs@reserved@C\@xs@reserved@D
-		\expandafter\@xs@StrSplit@i\expandafter{\expandafter1\expandafter}\expandafter{\@xs@reserved@D}\@xs@reserved@C\@xs@reserved@D
-		\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@C}{#3}%
-	\fi}
+	\let\@xs@reserved@B\@empty
+	\ifnum#2>\z@
+		\def\@xs@reserved@C{#1}\def\@xs@reserved@D{#2}\@xs@count\z@
+		\def\groupID{0}\let\@xs@nestlevel\z@\integerpart\z@
+		\let\@xs@atbegingroup\relax
+		\def\@xs@atendofgroup{\endgroup\@xs@read@reserved@C}%
+		\def\@xs@atnextsyntaxunit{%
+			\ifnum\@xs@count=\@xs@reserved@D% la n i\`eme US est atteinte ?
+				\global\let\@xs@reserved@B\@xs@reserved@A% on capture l'US en cours qui est celle cherch\'ee
+				\global\let\groupID\groupID
+				\@xs@exitallgroups
+				\let\@xs@next\relax
+			\fi}%
+		\@xs@read@reserved@C
+	\fi
+	\ifx\@xs@reserved@B\@empty\let\groupID\@empty\fi
+	\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@B}{#3}}
 
 % Combien de fois compte t-on #2 dans #1 ?
-% utilise \@xs@reserved@A -> \@xs@reserved@C en mode arg
 \@xs@newmacro\StrCount{}{2}{1}{%
 	\ifx\@empty#2\@empty
-		\@xs@ArgEmpty
-		\def\@xs@StrCount@afterlastocccur{}%
 		\@xs@ReturnResult{0}{#3}%
 	\else
-		\@xs@StrCount@i{#1}{#2}{#3}%
+		\def\@xs@reserved@D{#1}\def\@xs@reserved@E{#2}\let\@xs@reserved@C\@empty
+		\@xs@count\z@\integerpart\z@\def\groupID{0}\let\@xs@nestlevel\z@
+		\def\@xs@atendofgroup{%
+			\expandafter\endgroup
+			\expandafter\@xs@addtomacro\expandafter\@xs@reserved@C\expandafter{\expandafter{\@xs@reserved@C}}%
+			\@xs@read@reserved@D}%
+		\def\@xs@atoccurfound{\let\@xs@reserved@C\@empty\@xs@read@reserved@D}%
+		\@xs@read@reserved@D
+		\expandafter\@xs@ReturnResult\expandafter{\number\@xs@count}{#3}%
 	\fi}
-\def\@xs@StrCount@i#1#2#3{%
-	\def\@xs@StrCount@ii{%
-		\ifx\@xs@reserved@C\@empty% on a fini de parcourir \@xs@reserved@C ?
-			\let\@xs@next\relax% on sort de la macro
-		\else
-			\expandafter\@xs@IfBeginWith@i\expandafter{\@xs@reserved@C}{#2}%
-				{\global\advance\@xs@count\@ne
-				 \let\@xs@StrCount@afterlastocccur\@xs@reserved@A
-				 \let\@xs@reserved@C\@xs@reserved@A}% on enlève le motif à \@xs@reserved@C
-				{\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@A% \@xs@reserved@C ne commence pas par le motif : on prend la 1ere unité syntaxique
-				 \expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C% puis on l'enlève
-				 \@xs@exploregroups
-				 \ifx\bgroup\@xs@toks% si cette unité syntaxique est un groupe {...}
-				 	\begingroup% alors on ouvre un groupe
-				 		\expandafter\def\expandafter\@xs@reserved@C\@xs@reserved@A% \@xs@reserved@C devient l'intérieur de {...}
-				 		\@xs@StrCount@ii% on lance la macro avec ces nouvelles définitions
-				 	\endgroup
-				 \fi}%
-			\let\@xs@next\@xs@StrCount@ii
-		\fi
-		\@xs@next}%
-	\def\@xs@reserved@C{#1}\def\@xs@StrCount@afterlastocccur{#1}%
-	\@xs@count\z@
-	\@xs@StrCount@ii
-	\expandafter\@xs@ReturnResult\expandafter{\number\@xs@count}{#3}}
 
 % renvoie la position de l'occurrence #1 de la sous chaine #3 dans la chaine #2
 \@xs@newmacro\StrPosition{1}{2}{1}{%
-	\@xs@cutafteroccur{#2}{#3}{#1}\@xs@reserved@C\@xs@reserved@D\@xs@reserved@E
+	\@xs@cutafteroccur{#2}{#3}{#1}%
+	\let\@xs@reserved@E\groupID
 	\ifx\@xs@reserved@C\@xs@reserved@D
 		\@xs@ReturnResult{0}{#4}%
+		\let\@xs@reserved@E\@empty
 	\else
-		\ifx\@empty\@xs@exploregroups% on explore les groupes ?
-			\expandafter\@xs@StrLen\expandafter{\@xs@beforeoccur}[\@xs@reserved@D]%
-		\else
-			\expandafter\@xs@StrLen\expandafter{\@xs@reserved@D}[\@xs@reserved@D]%
-		\fi
-		\expandafter\@xs@ReturnResult\expandafter{\number\numexpr\@xs@reserved@D+1}{#4}%
-	\fi}
+		\expandafter\@xs@StrLen\expandafter{\@xs@reserved@C}[\@xs@reserved@C]%
+		\expandafter\@xs@ReturnResult\expandafter{\number\numexpr\@xs@reserved@C+1}{#4}%
+	\fi
+	\let\groupID\@xs@reserved@E}
 
-\def\comparestrict{\def\@xs@comparecoeff{1}}
-\def\comparenormal{\def\@xs@comparecoeff{0}}
+\def\comparestrict{\let\@xs@comparecoeff\@ne}
+\def\comparenormal{\let\@xs@comparecoeff\z@}
 \def\savecomparemode{\let\@xs@saved@comparecoeff\@xs@comparecoeff}
 \def\restorecomparemode{\let\@xs@comparecoeff\@xs@saved@comparecoeff}
 % Compare les deux arguments #1 et #2
-% Renvoie 0 s'ils sont égaux et renvoie la
-% position du premier token différent sinon
-\@xs@newmacro\StrCompare{}{2}{1}{%
+% Renvoie 0 s'ils sont \'egaux et renvoie la
+% position de la premiere unit\'e syntaxiques diff\'erente sinon
+\@xs@newmacro*2\StrCompare{}{2}{1}{%
 	\def\@xs@reserved@A{#1}%
 	\def\@xs@reserved@B{#2}%
 	\ifx\@xs@reserved@B\@xs@reserved@A
@@ -848,23 +888,66 @@
 		\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@D}\@xs@reserved@B
 		\ifx\@xs@reserved@B\@xs@reserved@A
 			\ifx\@xs@reserved@A\@empty
-				\@xs@StrCompare@iii{##1}% les 2 unités syntaxiques sont égales, on renvoie la position
+				\@xs@StrCompare@iii{##1}% les 2 unit\'es syntaxiques sont \'egales, on renvoie la position
 			\else
-				\def\@xs@next{\expandafter\@xs@StrCompare@ii\expandafter{\number\numexpr##1+1}}% les 2 unités syntaxiques sont égales et non vides, on recommence
+				\def\@xs@next{\expandafter\@xs@StrCompare@ii\expandafter{\number\numexpr##1+1}}% les 2 unit\'es syntaxiques sont \'egales et non vides, on recommence
 				\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C
 				\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@D}\@xs@reserved@D
 			\fi
-		\else% les 2 caractères sont différents : on renvoie la position
+		\else% les 2 unit\'es syntaxiques sont diff\'erentes : on renvoie la position
 			\@xs@StrCompare@iii{##1}%
 		\fi
 		\@xs@next}%
 	\def\@xs@reserved@C{#1}\def\@xs@reserved@D{#2}%
 	\@xs@StrCompare@ii1}
 
+\@xs@newmacro\StrFindGroup{}{2}{1}{%
+	\def\@xs@reserved@A{#2}\def\@xs@reserved@B{0}%
+	\ifx\@xs@reserved@A\@xs@reserved@B
+		\def\@xs@next{\@xs@ReturnResult{{#1}}{#3}}%
+	\else
+		\def\@xs@next{\@xs@StrFindGroup@i{#1}{#2}[#3]}%
+	\fi
+	\@xs@next}
+\def\@xs@StrFindGroup@i#1#2[#3]{%
+	\def\@xs@StrFindGroup@ii{%
+		\ifx\@xs@reserved@C\@empty
+			\def\@xs@next{\@xs@ReturnResult{}{#3}}% s'il ne reste plus rien, on renvoie vide
+		\else
+			\expandafter\@xs@returnfirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@D
+			\ifx\bgroup\@xs@toks% si la 1\`ere unit\'e syntaxique est un groupe explicite
+				\advance\@xs@count\@ne% on augmente le compteur
+				\ifnum\@xs@count=\@xs@reserved@A% on est au groupe cherch\'e lors de la profondeur courante ?
+					\ifx\@empty\@xs@reserved@B% on est \`a la profondeur maximale ?
+						\def\@xs@next{\expandafter\@xs@ReturnResult\expandafter{\@xs@reserved@D}{#3}}% on renvoie ce groupe
+					\else% sinon
+						\expandafter\def\expandafter\@xs@next\expandafter{\expandafter\@xs@StrFindGroup@i\@xs@reserved@D}% on recommence avec ce groupe
+						\expandafter\@xs@addtomacro\expandafter\@xs@next\expandafter{\expandafter{\@xs@reserved@B}[#3]}% et les profondeurs de recherche restantes
+					\fi
+				\else
+					\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C
+					\let\@xs@next\@xs@StrFindGroup@ii
+				\fi
+			\else
+				\expandafter\@xs@removefirstsyntaxunit\expandafter{\@xs@reserved@C}\@xs@reserved@C
+				\let\@xs@next\@xs@StrFindGroup@ii
+			\fi
+		\fi
+		\@xs@next}%
+	\@xs@extractgroupnumber{#2}\@xs@reserved@A\@xs@reserved@B
+	\@xs@count\z@
+	\ifnum\@xs@reserved@A>\z@\def\@xs@reserved@C{#1}\else\let\@xs@reserved@C\@empty\fi
+	\@xs@StrFindGroup@ii}
+
+\def\@xs@extractgroupnumber#1#2#3{%
+	\def\@xs@extractgroupnumber@i##1,##2\@xs@nil{\def#2{##1}\def#3{##2}}%
+	\@xs@extractgroupnumber@i#1,\@xs@nil
+	\ifx\@empty#3\else\@xs@extractgroupnumber@i#1\@xs@nil\fi}
+
 % Restaure le code de @
 \catcode`\@=\CurrentAtCatcode\relax
-% Définit le délimiteur verb
-% définit les différents modes et les mémorise
+% D\'efinit le d\'elimiteur verb
+% d\'efinit les diff\'erents modes et les m\'emorise
 \setverbdelim{|}%
 \fullexpandarg\saveexpandmode
 \comparenormal\savecomparemode
@@ -873,83 +956,101 @@
 %
 % Historique
 %------------------------------------------------------------------------------
-%% v1.0    4/7/2008 : - Package achevé.
-%          7/7/2008 : - Package publié sur CTAN.
+%% v1.0    4/7/2008 : - Package achev\'e.
+%          7/7/2008 : - Package publi\'e sur CTAN.
 %------------------------------------------------------------------------------
 % v1.1    15/8/2008
-%   - Le package ne nécessite plus LaTeX et est désormais utilisable sous Plain
-%     eTeX.
+%   - Le package ne n\'ecessite plus LaTeX et est d\'esormais utilisable sous
+%     Plain eTeX.
 %   - Ajout des macros \IfInteger et \IfDecimal.
-%     Pour cette dernière, la partie entière et la partie décimale sont
-%     récupérables dans les compteurs \integerpart et \decimalpart. Ce qu'il
-%     reste après qu'un caractère non attendu soit rencontré est dispo dans
-%     \@xs@remainafterdecimal
+%     Pour cette derni\`ere, la partie enti\`ere et la partie d\'ecimale sont
+%     r\'ecup\'erables dans les compteurs \integerpart et \decimalpart. Ce
+%     qu'il reste apr\`es qu'un caract\`ere non attendu soit rencontr\'e est
+%     dispo dans \@xs@remainafterdecimal
 %   - Correction d'un bug dans \tokenize :
-%        suppression de l'expansion avec \normalexpandarg pour éviter le bug
-%        avec les lettres accentuées dans l'exemple : \tokenize\aa{éù}
-%   - Amélioration du code de la plupart des macros.
-%   - Écriture d'une routine \@xs@newmacro définissant les  macros.
-%   - Suppression de tous les compteurs grace à \numexpr.
-%   - Nouvelles fonctionnalités internes dans :
+%        suppression de l'expansion avec \normalexpandarg pour \'eviter le bug
+%        avec les lettres accentu\'ees dans l'exemple : \tokenize\aa{\'e\`u}
+%   - Am\'elioration du code de la plupart des macros.
+%   - \'Ecriture d'une routine \@xs@newmacro d\'efinissant les  macros.
+%   - Suppression de tous les compteurs grace \`a \numexpr.
+%   - Nouvelles fonctionnalit\'es internes dans :
 %      \IfSubStr
-%        ajout des chaines se trouvant avant et après l'occurrence testée dans
-%        les sc \@xs@behind@IfSubStr et \@xs@before@IfSubStr
+%        ajout des chaines se trouvant avant et apr\`es l'occurrence test\'ee
+%        dans les sc \@xs@behind@IfSubStr et \@xs@before@IfSubStr
 %      \StrCount
-%        a) ajout de ce qui se trouve après la dernière occurrence dans la sc%
-%           \@xs@StrCount@afterlastocccur
-%        b) la macro ne dépend plus d'aucune autre
+%        a) ajout de ce qui se trouve apr\`es la derni\`ere occurrence dans la
+%           sc \@xs@StrCount@afterlastocccur
+%        b) la macro ne d\'epend plus d'aucune autre
 %------------------------------------------------------------------------------
 % v1.2    23/8/2008
-%   - Amélioration du code de \StrMid \StrGobbleLeft, \StrLeft, \StrGobbleRight
-%     et \StrRight à l'aide de la nouvelle macro \@xs@StrSplit@i
+%   - Am\'elioration du code de \StrMid \StrGobbleLeft, \StrLeft,
+%     \StrGobbleRight et \StrRight \`a l'aide de la nouvelle macro
+%     \@xs@StrSplit@i
 %   - Nouveau test \IfStrEq qui compare 2 chaines
 %   - Nouveau test \IfEq qui compare 2 chaines (ou 2 nombres si les 2 chaines
 %     contiennent un nombre)
 %   - Correction d'un bug dans \@xs@formatnumber. La macro n'envisageait pas le
-%     cas où son argument était vide ce qui faiasait planter \IfDecimal{}{V}{F}
-%     et \IfInteger{}{V}{F}
+%     cas o\`u son argument \'etait vide ce qui faiasait planter
+%     \IfDecimal{}{V}{F} et \IfInteger{}{V}{F}
 %------------------------------------------------------------------------------
 % v1.3    21/9/2008
-%  - Amélioration du code, mise en place de récursivités terminales dans toutes
-%    les macros récursives, simplification de \@xs@TestEqual en utilisant \ifx
+%  - Am\'elioration du code, mise en place de r\'ecursivit\'es terminales dans
+%    toutes les macros r\'ecursives, simplification de \@xs@TestEqual en
+%    utilisant \ifx
 %  - Nouvelles macros \IfStrEqCase et \IfEqCase
-%      Teste si une chaîne est égale à plusieurs chaînes donnée et exécute un
-%      code spécifique
-%  - Création de la macro publique \StrSplit
-%      Coupe la chaine en 2 à une position donnée
+%      Teste si une chaîne est \'egale \`a plusieurs chaînes donn\'ee et
+%      ex\'ecute un code sp\'ecifique
+%  - Cr\'eation de la macro publique \StrSplit
+%      Coupe la chaine en 2 \`a une position donn\'ee
 %  - Nouvelle macro \StrCompare
-%      Compare 2 chaînes et renvoie la position du 1er caractère différent.
-%      Renvoie 0 si elles sont égales.
+%      Compare 2 chaînes et renvoie la position du 1er caract\`ere diff\'erent.
+%      Renvoie 0 si elles sont \'egales.
 %------------------------------------------------------------------------------
 % v1.3a   29/9/2008
 %  - Correction d'un bug : \expandafter#1
 %    dans les macros \IfSubStrBefore et \StrBetween qui buggue si #1 est un
 %    nombre > 9 !
-%  - Ré écriture de \@xs@returnfirstsyntaxunit et \@xs@gobblefirstchar qui
-%    deviennent purement développables.
-%  - Ré écriture de \StrLen
+%  - R\'e \'ecriture de \@xs@returnfirstsyntaxunit et \@xs@gobblefirstchar qui
+%    deviennent purement d\'eveloppables.
+%  - R\'e \'ecriture de \StrLen
 %  - Nouvelle macro interne \@xs@cutafteroccur
-%      Coupe la chaine après la nième occurrence d'une sous chaine.
-%  - Code amélioré de \StrMid, \StrLeft, \StrGobbleLeft, \StrRight,
-%    \StrGobbleRight grace à \@xs@cutafteroccur
+%      Coupe la chaine apr\`es la ni\`eme occurrence d'une sous chaine.
+%  - Code am\'elior\'e de \StrMid, \StrLeft, \StrGobbleLeft, \StrRight,
+%    \StrGobbleRight grace \`a \@xs@cutafteroccur
 %------------------------------------------------------------------------------
 % v1.4   4/11/2008
-%  - xstring traite ses arguments par unité syntaxique, et donc toutes les
-%    macros internes ont été ré-écrites à cette fin.
-%  - Le manuel a été ré-écrit, rendu plus clair et mieux structuré.
-%  - Nouvelle fonctionnalité : \expandarg
-%      le 1er lexème de chaque argument est 1-développé avant que la macro ne
-%      soit appelée. Si un argument comporte plus qu'1 lexème, il faut passer
-%      par \scancs*[1] pour 1-développer toutes les unités syntaxiques.
+%  - xstring traite ses arguments par unit\'e syntaxique, et donc toutes les
+%    macros internes ont \'et\'e r\'e-\'ecrites \`a cette fin.
+%  - Le manuel a \'et\'e r\'e-\'ecrit, rendu plus clair et mieux structur\'e.
+%  - Nouvelle fonctionnalit\'e : \expandarg
+%      le 1er lex\`eme de chaque argument est 1-d\'evelopp\'e avant que la
+%      macro ne soit appel\'ee. Si un argument comporte plus qu'1 lex\`eme,
+%      il faut passer par \scancs*[1] pour 1-d\'evelopper toutes les unit\'es
+%      syntaxiques.
 %  - Correction de 2 erreurs dans le manuel anglais :  0 est la valeur par
-%    défaut dans \StrSubstitute et \StrDel
-%  - Cohérence dans les nom des séquences de contrôles temporaires qui sont
-%    \@xs@reserved@A -> \@xs@reserved@E
+%    d\'efaut dans \StrSubstitute et \StrDel
+%  - Coh\'erence dans les nom des s\'equences de contr\^oles temporaires qui
+%    sont d\'esormais : \@xs@reserved@A \`a \@xs@reserved@E
 %------------------------------------------------------------------------------
 % v1.4a  12/11/2008
-%  - Correction d'un bug dans \@xs@StrSplit dans le cas où l'argument numérique
-%    est <1 : la 1ere coupure doit être vide et le seconde doit être égale à
-%    l'argument.
+%  - Correction d'un bug dans \@xs@StrSplit dans le cas o\`u l'argument
+%     num\'erique est <1 : la 1ere coupure doit être vide et le seconde doit
+%     être \'egale \`a l'argument.
 %------------------------------------------------------------------------------
 % v1.4b  16/11/2008
-%  - Correction de 2 bugs dans \@xs@returnfirstsyntaxunit
\ No newline at end of file
+%  - Correction de 2 bugs dans \@xs@returnfirstsyntaxunit
+%------------------------------------------------------------------------------
+% v1.5   31/12/2008
+%  - Nouvelles fonctionnalit\'es dans la recherche de groupes par un
+%    identificateur caract\'erisant leur imbrication. Impl\'ementation de :
+%      1) \StrFindGroup
+%      2) \groupID
+%  - Ajout des nouvelles macros g\'en\'eriques \@xs@read@reserved@C et
+%    \@xs@read@reserved@D
+%  - Correction d'un bug dans \StrSplit : \StrSplit{{a}bc}{1}[\truc] faisait
+%    que \truc contenait «a{a}».
+%  - Correction d'un bug dans \@xs@newmacro : l'argument optionnel \'etait
+%    d\'etok\'enis\'e \`a tort dans les macros \'etoil\'ees.
+%  - Dans \@xs@newmacro, on doit choisir le num\'ero du dernier argument devant
+%    être d\'etok\'enis\'e dans le cas d'une macro \'etoil\'ee (sachant que
+%     l'argument optionnel ne l'est jamais)
\ No newline at end of file
diff --git a/Master/tlpkg/bin/tlpkginfo b/Master/tlpkg/bin/tlpkginfo
index 4f1570ff7f3..6c09a8329ea 100755
--- a/Master/tlpkg/bin/tlpkginfo
+++ b/Master/tlpkg/bin/tlpkginfo
@@ -18,7 +18,7 @@ sub main
   
   # erroneous tds files (warn Robin about them)
   # list format: pkg1|pkg2|etc
-  $erroneous_tds = "bidi|elsarticle";
+  $erroneous_tds = "bidi|elsarticle|xstring";
 
   # special packages from latex-tds project (used by prepare())
   $corelatex_tds_pkgs = "babel|cyrillic|graphics|latex|psnfss|tools";