summaryrefslogtreecommitdiff
path: root/macros/generic
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2023-08-23 03:01:02 +0000
committerNorbert Preining <norbert@preining.info>2023-08-23 03:01:02 +0000
commit76d75859475de5b0b64017c9dfc11644a2ece537 (patch)
treee2f334df5d811d8fe54215e0591eaf227de58fe0 /macros/generic
parentcf3e954514eb50bea0335bdc97d6b76f80f5d03e (diff)
CTAN sync 202308230300
Diffstat (limited to 'macros/generic')
-rw-r--r--macros/generic/xstring/README4
-rw-r--r--macros/generic/xstring/test_etex.pdfbin99781 -> 99781 bytes
-rw-r--r--macros/generic/xstring/test_latex.pdfbin154972 -> 49911 bytes
-rw-r--r--macros/generic/xstring/test_latex.tex3
-rw-r--r--macros/generic/xstring/xstring-en.pdfbin336458 -> 245790 bytes
-rw-r--r--macros/generic/xstring/xstring-en.tex1773
-rw-r--r--macros/generic/xstring/xstring-fr.pdfbin341138 -> 238471 bytes
-rw-r--r--macros/generic/xstring/xstring-fr.tex1752
-rw-r--r--macros/generic/xstring/xstring.tex337
9 files changed, 1119 insertions, 2750 deletions
diff --git a/macros/generic/xstring/README b/macros/generic/xstring/README
index 812db6aaf2..849508c7a9 100644
--- a/macros/generic/xstring/README
+++ b/macros/generic/xstring/README
@@ -1,8 +1,8 @@
_________________
xstring package
- v 1.85
- 2023/01/14
+ v 1.86
+ 2023/08/22
_________________
This package provides macros manipulating strings for programming use.
diff --git a/macros/generic/xstring/test_etex.pdf b/macros/generic/xstring/test_etex.pdf
index 0f00223840..ca121d4ab9 100644
--- a/macros/generic/xstring/test_etex.pdf
+++ b/macros/generic/xstring/test_etex.pdf
Binary files differ
diff --git a/macros/generic/xstring/test_latex.pdf b/macros/generic/xstring/test_latex.pdf
index 2a01937b6c..8261a28af7 100644
--- a/macros/generic/xstring/test_latex.pdf
+++ b/macros/generic/xstring/test_latex.pdf
Binary files differ
diff --git a/macros/generic/xstring/test_latex.tex b/macros/generic/xstring/test_latex.tex
index ca5d54f022..47923d8720 100644
--- a/macros/generic/xstring/test_latex.tex
+++ b/macros/generic/xstring/test_latex.tex
@@ -1,7 +1,6 @@
% Ceci est test_latex.tex, le fichier de test de xstring à compiler avec LaTeX
+% !TeX TS-program = lualatex
\documentclass[a4paper,10pt]{article}
-\usepackage[utf8]{inputenc}
-\usepackage[T1]{fontenc}
\usepackage{lmodern}
\usepackage[margin=1cm,noheadfoot]{geometry}
\pagestyle{empty}
diff --git a/macros/generic/xstring/xstring-en.pdf b/macros/generic/xstring/xstring-en.pdf
index 554faf4cea..6cf5ec91cb 100644
--- a/macros/generic/xstring/xstring-en.pdf
+++ b/macros/generic/xstring/xstring-en.pdf
Binary files differ
diff --git a/macros/generic/xstring/xstring-en.tex b/macros/generic/xstring/xstring-en.tex
index 61b6ad8078..882133ef7d 100644
--- a/macros/generic/xstring/xstring-en.tex
+++ b/macros/generic/xstring/xstring-en.tex
@@ -1,3 +1,4 @@
+% !TeX TS-program = lualatex
\documentclass[english,a4paper,10pt]{article}
\usepackage{fontspec}
\usepackage[bookmarks=true,bookmarksopen=true,colorlinks=true,hyperfootnotes=false,filecolor=black,linkcolor=blue,urlcolor=blue,pdfauthor={Christian Tellechea},pdftitle={xstring},pdfsubject={package for strings of tokens},pdfkeywords={xstring,latex,string},pdfcreator={LaTeX}]{hyperref}
@@ -5,58 +6,97 @@
\usepackage{libertine}
\usepackage[scale=0.85]{noto-mono}
\usepackage[bottom]{footmisc}
-\usepackage{amsmath,amssymb,amsfonts,color,eurosym,xspace,xstring,babel,listings}
+\usepackage{amsmath,amssymb,amsfonts,xcolor,eurosym,xspace,xstring,babel}
\makeatletter
-\definecolor{@xs@bckgcolor}{rgb}{0.9,1,1}
-\definecolor{@xs@keywordsxstring}{rgb}{0,0,0.9}
-\definecolor{@xs@keywordslatex}{rgb}{1,0,0}
-\definecolor{@xs@arguments}{rgb}{0,0,0}
-\definecolor{@xs@comments}{rgb}{0.5,0.5,0.5}
+\newcommand\make@car@active[1]{%
+ \catcode`#1\active
+ \begingroup
+ \lccode`\~`#1\relax
+ \lowercase{\endgroup\def~}%
+}
+
+\newcount\code@line
+\newbox\box@code
+\newbox\box@exec
+\newbox\box@bkgd
+
+\newcommand*\showcode{%
+ \begingroup
+ \parskip\z@
+ \parindent\z@
+ \code@line\z@
+ \@makeother\;\@makeother\!\@makeother\?\@makeother\:
+ \medbreak
+ \noindent
+ \begingroup
+ \let\do\@makeother\dospecials
+ \make@car@active\ { }%
+ \make@car@active\^^M{\par\leavevmode}%
+ \make@car@active\^^I{\space\space\space\space}%
+ \make@car@active\,{\leavevmode\kern\z@\string,}%
+ \make@car@active\-{\leavevmode\kern\z@\string-}%
+ \showcode@a
+}
+
+\newcommand\showcode@a[2][65]{%
+ \def\@tempa##1#2{%
+ \xdef\the@code{##1}%
+ \endgroup
+ \showcode@b{#1}{##1}}%
+ \@tempa}
+
+\newcommand\showcode@b[2]{%
+ \vskip0.5ex
+ \fboxsep5pt
+ \setbox\box@code=\hbox{%
+ $\vcenter{
+ \hsize\dimexpr0.#1\linewidth-\fboxsep-\fboxrule\relax
+ \parskip0pt
+ \ttfamily
+ \small
+ \everypar{\llap{\global\advance\code@line\@ne\tiny\number\code@line\kern\dimexpr\fboxsep+3pt }}%
+ \the@code\par
+ }$%
+ }%
+ \setbox\box@exec=\hbox{%
+ $\vcenter{
+ \hsize\dimexpr\linewidth-0.#1\linewidth-\fboxsep-\fboxrule\relax
+ \small
+ \newlinechar`\^^M\everyeof{\noexpand}%
+ \scantokens{#2}%
+ }$%
+ }%
+ \fbox{%
+ \begingroup
+ \color{black!15}%
+ \setbox\box@bkgd=\hbox{% fond code
+ \vrule width\wd\box@code
+ height\dimexpr\max@dim{\ht\box@code}{\ht\box@exec}+\fboxsep\relax
+ depth \dimexpr\max@dim{\dp\box@code}{\dp\box@exec}+\fboxsep\relax
+ }%
+ \wd\box@bkgd=0pt \ht\box@bkgd=0pt \dp\box@bkgd=0pt
+ \kern-\fboxsep
+ \box\box@bkgd
+ \kern\fboxsep
+ \endgroup
+ \setbox\box@bkgd=\hbox{% réglure verticale
+ \vrule width.5pt
+ height\dimexpr\max@dim{\ht\box@code}{\ht\box@exec}+\fboxsep\relax
+ depth \dimexpr\max@dim{\dp\box@code}{\dp\box@exec}+\fboxsep\relax
+ }%
+ \box\box@code
+ \wd\box@bkgd=0pt \ht\box@bkgd=0pt \dp\box@bkgd=0pt
+ \kern-\fboxsep
+ \box\box@bkgd
+ \kern\fboxsep
+ \box\box@exec
+ }%
+ \medbreak
+ \endgroup
+}
+\def\max@dim#1#2{\ifdim#1>#2 #1\else#2\fi}
+
\definecolor{violet}{rgb}{0.66,0,0.66}
-\lstset{%
- language=[AlLaTeX]TeX,%
- morekeywords={numexpr,detokenize},%
- float=hbp,%
- basicstyle=\small\ttfamily,%
- identifierstyle=\color{@xs@arguments},%
- keywordstyle=\color{@xs@keywordslatex},%
- commentstyle=\itshape\color{@xs@comments},%
- columns=fixed,%
- tabsize=4,%
- frame=single,%
- extendedchars=true,%
- showspaces=false,%
- showstringspaces=false,%
- numbers=left,%
- numberstyle=\tiny\ttfamily,%
- breaklines=true,%
- breakindent=3em,%
- backgroundcolor=\color{@xs@bckgcolor},%
- breakautoindent=true,%
- captionpos=t,%
- xleftmargin=1em,%
- xrightmargin=1em,%
- lineskip=0pt,%
- numbersep=1em,%
- classoffset=1,%
- morekeywords={% les macros et commandes de xstring
- IfSubStr,IfSubStrBefore,IfSubStrBehind,%
- IfBeginWith,IfEndWith,%
- IfInteger,IfDecimal,integerpart,decimalpart,%
- IfStrEq,IfEq,IfStrEqCase,IfEqCase,%
- StrBefore,StrBehind,StrCut,StrBetween,%
- StrSubstitute,StrDel,%
- StrGobbleLeft,StrGobbleRight,StrRight,StrLeft,StrMid,StrChar,%
- StrSplit,%
- StrLen,StrCount,StrPosition,StrCompare,%
- StrFindGroup,groupID,verbtocs,tokenize,scancs,StrExpand,StrRemoveBraces,%
- exploregroups,noexploregroups,saveexploremode,restoreexploremode,%
- comparenormal,comparestrict,savecomparemode,restorecomparemode,%
- expandarg,noexpandarg,normalexpandarg,fullexpandarg,saveexpandmode,restoreexpandmode,%
- expandingroups,noexpandingroups,%
- setverbdelim},%
- keywordstyle=\color{@xs@keywordsxstring},%
- classoffset=0}
\makeatother
\newcommand\guill[1]{"#1"}
@@ -81,7 +121,6 @@
\newcommand\Xstring{\textsf{xstring}\xspace}
\newcommand\styleexemple{\small\baselineskip1.03\baselineskip\vskip\baselineskip\relax}
\newcommand\styleexercice{\footnotesize}
-\newcommand\verbinline{\lstinline[basicstyle=\normalsize\ttfamily]}
\newcommand\colorise{\color{violet}}
\def\xstringenglishdateaux#1/#2/#3\nil{\number#3\relax\space \ifcase #2 \or January\or February\or March\or April\or May\or June\or July\or August\or September\or October\or November\or December\fi\space#1}
\edef\xstringenglishdate{\expandafter\xstringenglishdateaux\xstringdate\nil}
@@ -109,37 +148,7 @@
\begin{minipage}{0.85\linewidth}
\noindent
\hfill\textbf{\textit{Abstract}}\hfill{}\medskip\par
- 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:\smallskip
-
- \parindent1.5em
- \begin{itemize}
- \item[$\triangleright$] tests:
- \begin{itemize}
- \item does a string contains at least $n$ times an another?
- \item does a string starts (or ends) with another? etc.
- \item is a string an integer? A decimal?
- \item are 2 strings equal?
- \end{itemize}
- \item[$\triangleright$] extractions of substrings:
- \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;
- \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:
- \begin{itemize}
- \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 identifier of the group in which a macro made a cut or a search.
- \end{itemize}
- \end{itemize}
- \parindent0pt
- \medskip
- Other macros allow to use special characters forbiden in arguments (\verb|#| and \verb|%|) and manage differences between catcodes for advanced programming purposes.
+ This package provides non expandable macros for manipulating code made 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.
\end{minipage}
\end{center}
\hrulefill\vfill{}
@@ -149,22 +158,16 @@
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 tokens", 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 non expandable macros and tests operating on "strings of tokens", 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
-A "string of tokens" is a list of tokens of any nature, except that braces must be balanced and tokens catcode 6 and 14 (usualy \verb|%| et \verb|#|) are not allowed. Apart from this, any token is allowed (including \verbinline|\par|), in any order in the list, whatever be the resulting code.\medskip
+A "string of tokens" is a list of tokens of any nature, except that braces must be balanced and tokens catcode 6 and 14 (usualy \verb|%| et \verb|#|) are not allowed. Apart from this, any token is allowed (including \verb|\par|), in any order in the list, whatever be the resulting code.\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 \verbinline|\verbtocs| (page~\pageref{verbtocs}) and the command \verbinline|\scancs| (page~\pageref{scancs}).\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 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://mirror.ctan.org/tex-archive/macros/latex/contrib/substr/}{\nolinkurl{substr}} and \href{http://mirror.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.
-\subsection{Motivation}
-I decided to write this package of macros because I have never really found tools in \LaTeX{} suiting my needs for strings. So, over the last few months, I wrote a few macros that I occasionally or regularly used. Their numbers have increased and become a little too dispersed in directories in my computer, so I have grouped them together in this package.
-
-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}
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
@@ -176,13 +179,11 @@ In the following chapters, all the macros will be presented this plan:
\item finally, several examples\footnote{For much more examples, see the test file.} are given. I tried to find them most easily comprehensible and most representative of the situations met in normal use. If a doubt is possible with spaces in the result, this one will be delimited by \guill{|}, given that an empty string is represented by \guill{||}.
\end{itemize}\smallskip
-\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 \verbinline|\numexpr|.\smallskip
-
-All the macros of \Xstring are displayed in {\makeatletter\color{@xs@keywordsxstring}blue}.
+\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|.\smallskip
\subsection{The tests}
\subsubsection{\ttfamily\textbackslash IfSubStr}
-\verbinline|\IfSubStr|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\ARGU{true}\ARGU{false}
+\verb|\IfSubStr|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\ARGU{true}\ARGU{false}
\smallskip
The value of the optional argument \argu{number} is 1 by default.\par\smallskip
@@ -194,30 +195,16 @@ Tests if \argu{string} contains at least \argu{number} times \argu{stringA} and
\item If \argu{string} or \argu{stringA} is empty, runs \argu{false}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfSubStr{xstring}{tri}{true}{false}
-\IfSubStr{xstring}{a}{true}{false}
-\IfSubStr{a bc def }{c d}{true}{false}
-\IfSubStr{a bc def }{cd}{true}{false}
-\IfSubStr[2]{1a2a3a}{a}{true}{false}
-\IfSubStr[3]{1a2a3a}{a}{true}{false}
-\IfSubStr[4]{1a2a3a}{a}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfSubStr{xstring}{tri}{true}{false}\par
- \IfSubStr{xstring}{a}{true}{false}\par
- \IfSubStr{a bc def }{c d}{true}{false}\par
- \IfSubStr{a bc def }{cd}{true}{false}\par
- \IfSubStr[2]{1a2a3a}{a}{true}{false}\par
- \IfSubStr[3]{1a2a3a}{a}{true}{false}\par
- \IfSubStr[4]{1a2a3a}{a}{true}{false}
-\end{minipage}%
+\showcode|\IfSubStr{xstring}{tri}{true}{false}\par
+\IfSubStr{xstring}{a}{true}{false}\par
+\IfSubStr{a bc def }{c d}{true}{false}\par
+\IfSubStr{a bc def }{cd}{true}{false}\par
+\IfSubStr[2]{1a2a3a}{a}{true}{false}\par
+\IfSubStr[3]{1a2a3a}{a}{true}{false}\par
+\IfSubStr[4]{1a2a3a}{a}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfSubStrBefore}
-\verbinline|\IfSubStrBefore|\etoile\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
+\verb|\IfSubStrBefore|\etoile\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
\smallskip
The values of the optional arguments \argu{number1} and \argu{number2} are 1 by default.\par\smallskip
@@ -230,35 +217,18 @@ In \argu{string}, tests if the \argu{number1}\th occurrence of \argu{stringA} is
\item If one of the optional arguments is negative or zero, runs \argu{false}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfSubStrBefore{xstring}{st}{in}{true}{false}
-\IfSubStrBefore{xstring}{ri}{s}{true}{false}
-\IfSubStrBefore{LaTeX}{LaT}{TeX}{true}{false}
-\IfSubStrBefore{a bc def }{ b}{ef}{true}{false}
-\IfSubStrBefore{a bc def }{ab}{ef}{true}{false}
-\IfSubStrBefore[2,1]{b1b2b3}{b}{2}{true}{false}
-\IfSubStrBefore[3,1]{b1b2b3}{b}{2}{true}{false}
-\IfSubStrBefore[2,2]{baobab}{a}{b}{true}{false}
-\IfSubStrBefore[2,3]{baobab}{a}{b}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfSubStrBefore{xstring}{st}{in}{true}{false}\par
- \IfSubStrBefore{xstring}{ri}{s}{true}{false}\par
- \IfSubStrBefore{LaTeX}{LaT}{TeX}{true}{false}\par
- \IfSubStrBefore{a bc def }{ b}{ef}{true}{false}\par
- \IfSubStrBefore{a bc def }{ab}{ef}{true}{false}\par
- \IfSubStrBefore[2,1]{b1b2b3}{b}{2}{true}{false}\par
- \IfSubStrBefore[3,1]{b1b2b3}{b}{2}{true}{false}\par
- \IfSubStrBefore[2,2]{baobab}{a}{b}{true}{false}\par
- \IfSubStrBefore[2,3]{baobab}{a}{b}{true}{false}
-\end{minipage}%
+\showcode|\IfSubStrBefore{xstring}{st}{in}{true}{false}\par
+\IfSubStrBefore{xstring}{ri}{s}{true}{false}\par
+\IfSubStrBefore{LaTeX}{LaT}{TeX}{true}{false}\par
+\IfSubStrBefore{a bc def }{ b}{ef}{true}{false}\par
+\IfSubStrBefore{a bc def }{ab}{ef}{true}{false}\par
+\IfSubStrBefore[2,1]{b1b2b3}{b}{2}{true}{false}\par
+\IfSubStrBefore[3,1]{b1b2b3}{b}{2}{true}{false}\par
+\IfSubStrBefore[2,2]{baobab}{a}{b}{true}{false}\par
+\IfSubStrBefore[2,3]{baobab}{a}{b}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfSubStrBehind}
-
-\verbinline|\IfSubStrBehind|\etoile\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
+\verb|\IfSubStrBehind|\etoile\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
\smallskip
The values of the optional arguments \argu{number1} and \argu{number2} are 1 by default.\par\smallskip
@@ -271,35 +241,18 @@ In \argu{string}, tests if the \argu{number1}\th occurrence of \argu{stringA} is
\item If one of the optional arguments is negative or zero, runs \argu{false}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfSubStrBehind{xstring}{ri}{xs}{true}{false}
-\IfSubStrBehind{xstring}{s}{i}{true}{false}
-\IfSubStrBehind{LaTeX}{TeX}{LaT}{true}{false}
-\IfSubStrBehind{a bc def }{ d}{a}{true}{false}
-\IfSubStrBehind{a bc def }{cd}{a b}{true}{false}
-\IfSubStrBehind[2,1]{b1b2b3}{b}{2}{true}{false}
-\IfSubStrBehind[3,1]{b1b2b3}{b}{2}{true}{false}
-\IfSubStrBehind[2,2]{baobab}{b}{a}{true}{false}
-\IfSubStrBehind[2,3]{baobab}{b}{a}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfSubStrBehind{xstring}{ri}{xs}{true}{false}\par
- \IfSubStrBehind{xstring}{s}{i}{true}{false}\par
- \IfSubStrBehind{LaTeX}{TeX}{LaT}{true}{false}\par
- \IfSubStrBehind{a bc def }{ d}{a}{true}{false}\par
- \IfSubStrBehind{a bc def }{cd}{a b}{true}{false}\par
- \IfSubStrBehind[2,1]{b1b2b3}{b}{2}{true}{false}\par
- \IfSubStrBehind[3,1]{b1b2b3}{b}{2}{true}{false}\par
- \IfSubStrBehind[2,2]{baobab}{b}{a}{true}{false}\par
- \IfSubStrBehind[2,3]{baobab}{b}{a}{true}{false}
-\end{minipage}%
+\showcode|\IfSubStrBehind{xstring}{ri}{xs}{true}{false}\par
+\IfSubStrBehind{xstring}{s}{i}{true}{false}\par
+\IfSubStrBehind{LaTeX}{TeX}{LaT}{true}{false}\par
+\IfSubStrBehind{a bc def }{ d}{a}{true}{false}\par
+\IfSubStrBehind{a bc def }{cd}{a b}{true}{false}\par
+\IfSubStrBehind[2,1]{b1b2b3}{b}{2}{true}{false}\par
+\IfSubStrBehind[3,1]{b1b2b3}{b}{2}{true}{false}\par
+\IfSubStrBehind[2,2]{baobab}{b}{a}{true}{false}\par
+\IfSubStrBehind[2,3]{baobab}{b}{a}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfBeginWith}
-
-\verbinline|\IfBeginWith|\etoile\ARGU{string}\ARGU{stringA}\ARGU{true}\ARGU{false}
+\verb|\IfBeginWith|\etoile\ARGU{string}\ARGU{stringA}\ARGU{true}\ARGU{false}
\smallskip
Tests if \argu{string} begins with \argu{stringA}, and runs \argu{true} if so, and \argu{false} otherwise.\medskip
@@ -308,25 +261,13 @@ Tests if \argu{string} begins with \argu{stringA}, and runs \argu{true} if so, a
\item If \argu{string} or \argu{stringA} is empty, runs \argu{false}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfBeginWith{xstring}{xst}{true}{false}
-\IfBeginWith{LaTeX}{a}{true}{false}
-\IfBeginWith{a bc def }{a b}{true}{false}
-\IfBeginWith{a bc def }{ab}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfBeginWith{xstring}{xst}{true}{false}\par
- \IfBeginWith{LaTeX}{a}{true}{false}\par
- \IfBeginWith{a bc def }{a b}{true}{false}\par
- \IfBeginWith{a bc def }{ab}{true}{false}
-\end{minipage}%
+\showcode|\IfBeginWith{xstring}{xst}{true}{false}\par
+\IfBeginWith{LaTeX}{a}{true}{false}\par
+\IfBeginWith{a bc def }{a b}{true}{false}\par
+\IfBeginWith{a bc def }{ab}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfEndWith}
-
-\verbinline|\IfEndWith|\etoile\ARGU{string}\ARGU{stringA}\ARGU{Behind}\ARGU{false}
+\verb|\IfEndWith|\etoile\ARGU{string}\ARGU{stringA}\ARGU{Behind}\ARGU{false}
\smallskip
Tests if \argu{string} ends with \argu{stringA}, and runs \argu{true} if so, and \argu{false} otherwise.\medskip
@@ -335,69 +276,39 @@ Tests if \argu{string} ends with \argu{stringA}, and runs \argu{true} if so, and
\item If \argu{string} or \argu{stringA} is empty, runs \argu{false}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfEndWith{xstring}{ring}{true}{false}
-\IfEndWith{LaTeX}{a}{true}{false}
-\IfEndWith{a bc def }{ef }{true}{false}
-\IfEndWith{a bc def }{ef}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfEndWith{xstring}{ring}{true}{false}\par
- \IfEndWith{LaTeX}{a}{true}{false}\par
- \IfEndWith{a bc def }{ef }{true}{false}\par
- \IfEndWith{a bc def }{ef}{true}{false}
-\end{minipage}%
+\showcode|\IfEndWith{xstring}{ring}{true}{false}\par
+\IfEndWith{LaTeX}{a}{true}{false}\par
+\IfEndWith{a bc def }{ef }{true}{false}\par
+\IfEndWith{a bc def }{ef}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfInteger}
-
-\verbinline|\IfInteger|\ARGU{number}\ARGU{true}\ARGU{false}
+\verb|\IfInteger|\ARGU{number}\ARGU{true}\ARGU{false}
\smallskip
Tests if \argu{number} is an integer (i.e whose decimal part is empty or 0), and runs \argu{true} if so, and \argu{false} otherwise.\smallskip
-If test is false because unexpected characters, the control sequence \verbinline|\@xs@afterinteger| and \verbinline|\afterinteger| both contain the illegal part of \argu{number}.\medskip
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfInteger{13}{true}{false}
-\IfInteger{-219}{true}{false}
-\IfInteger{+9}{true}{false}
-\IfInteger{3.14}{true}{false}
-\IfInteger{8.0}{true}{false}
-\IfInteger{0}{true}{false}
-\IfInteger{49a}{true}{false}
-\IfInteger{+}{true}{false}
-\IfInteger{-}{true}{false}
-\IfInteger{0000}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfInteger{13}{true}{false}\par
- \IfInteger{-219}{true}{false}\par
- \IfInteger{+9}{true}{false}\par
- \IfInteger{3.14}{true}{false}\par
- \IfInteger{8.0}{true}{false}\par
- \IfInteger{0}{true}{false}\par
- \IfInteger{49a}{true}{false}\par
- \IfInteger{+}{true}{false}\par
- \IfInteger{-}{true}{false}\par
- \IfInteger{0000}{true}{false}
-\end{minipage}%
+If test is false because unexpected characters, the control sequence \verb|\afterinteger| contains the illegal part of \argu{number}.\medskip
-\subsubsection{\ttfamily\textbackslash IfDecimal}\label{ifdecimal}
+\showcode|\IfInteger{13}{true}{false}\par
+\IfInteger{-219}{true}{false}\par
+\IfInteger{+9}{true}{false}\par
+\IfInteger{3.14}{true}{false}\par
+\IfInteger{8.0}{true}{false}\par
+\IfInteger{0}{true}{false}\par
+\IfInteger{49a}{true}{false}\par
+\IfInteger{+}{true}{false}\par
+\IfInteger{-}{true}{false}\par
+\IfInteger{0000}{true}{false}|
-\verbinline|\IfDecimal|\ARGU{number}\ARGU{true}\ARGU{false}
+\subsubsection{\ttfamily\textbackslash IfDecimal}\label{ifdecimal}
+\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
-Counters \verbinline|\integerpart| and \verbinline|\decimalpart| contain the integer part and decimal part of \argu{number}.
+Macros \verb|\integerpart| and \verb|\decimalpart| contain the integer part and decimal part of \argu{number}.
-If test is false because unexpected characters, the control sequence \verbinline|\@xs@afterdecimal| and \verb|\afterdecimal| both contain the illegal part of \argu{number}, whereas if test is false because decimal part is empty after decimal separator, they contain "X".\medskip
+If test is false because unexpected characters, the control sequence \verb|\afterdecimal| contain the illegal part of \argu{number}, whereas if test is false because decimal part is empty after decimal separator, it contain "X".\medskip
\begin{Conditions}
\item Decimal separator can be a dot or a comma;
@@ -405,124 +316,65 @@ If test is false because unexpected characters, the control sequence \verbinline
\item If what is on the left of decimal separator (if it exists) is empty, the integer part is assumed to be 0;
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfDecimal{3.14}{true}{false}
-\IfDecimal{3,14}{true}{false}
-\IfDecimal{-0.5}{true}{false}
-\IfDecimal{.7}{true}{false}
-\IfDecimal{,9}{true}{false}
-\IfDecimal{1..2}{true}{false}
-\IfDecimal{+6}{true}{false}
-\IfDecimal{-15}{true}{false}
-\IfDecimal{1.}{true}{false}
-\IfDecimal{2,}{true}{false}
-\IfDecimal{.}{true}{false}
-\IfDecimal{,}{true}{false}
-\IfDecimal{+}{true}{false}
-\IfDecimal{-}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfDecimal{3.14}{true}{false}\par
- \IfDecimal{3,14}{true}{false}\par
- \IfDecimal{-0.5}{true}{false}\par
- \IfDecimal{.7}{true}{false}\par
- \IfDecimal{,9}{true}{false}\par
- \IfDecimal{1..2}{true}{false}\par
- \IfDecimal{+6}{true}{false}\par
- \IfDecimal{-15}{true}{false}\par
- \IfDecimal{1.}{true}{false}\par
- \IfDecimal{2,}{true}{false}\par
- \IfDecimal{.}{true}{false}\par
- \IfDecimal{,}{true}{false}\par
- \IfDecimal{+}{true}{false}\par
- \IfDecimal{-}{true}{false}
-\end{minipage}%
+\showcode|\IfDecimal{3.14}{true}{false}\par
+\IfDecimal{3,14}{true}{false}\par
+\IfDecimal{-0.5}{true}{false}\par
+\IfDecimal{.7}{true}{false}\par
+\IfDecimal{,9}{true}{false}\par
+\IfDecimal{1..2}{true}{false}\par
+\IfDecimal{+6}{true}{false}\par
+\IfDecimal{-15}{true}{false}\par
+\IfDecimal{1.}{true}{false}\par
+\IfDecimal{2,}{true}{false}\par
+\IfDecimal{.}{true}{false}\par
+\IfDecimal{,}{true}{false}\par
+\IfDecimal{+}{true}{false}\par
+\IfDecimal{-}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfStrEq}
-
-\verbinline|\IfStrEq|\etoile\ARGU{stringA}\ARGU{stringB}\ARGU{true}\ARGU{false}
+\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 \USs in the same order. Runs \argu{true} if so, and \argu{false} otherwise.\smallskip
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfStrEq{a1b2c3}{a1b2c3}{true}{false}
-\IfStrEq{abcdef}{abcd}{true}{false}
-\IfStrEq{abc}{abcdef}{true}{false}
-\IfStrEq{3,14}{3,14}{true}{false}
-\IfStrEq{12.34}{12.340}{true}{false}
-\IfStrEq{abc}{}{true}{false}
-\IfStrEq{}{abc}{true}{false}
-\IfStrEq{}{}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfStrEq{a1b2c3}{a1b2c3}{true}{false}\par
- \IfStrEq{abcdef}{abcd}{true}{false}\par
- \IfStrEq{abc}{abcdef}{true}{false}\par
- \IfStrEq{3,14}{3,14}{true}{false}\par
- \IfStrEq{12.34}{12.340}{true}{false}\par
- \IfStrEq{abc}{}{true}{false}\par
- \IfStrEq{}{abc}{true}{false}\par
- \IfStrEq{}{}{true}{false}
-\end{minipage}%
+\showcode|\IfStrEq{a1b2c3}{a1b2c3}{true}{false}\par
+\IfStrEq{abcdef}{abcd}{true}{false}\par
+\IfStrEq{abc}{abcdef}{true}{false}\par
+\IfStrEq{3,14}{3,14}{true}{false}\par
+\IfStrEq{12.34}{12.340}{true}{false}\par
+\IfStrEq{abc}{}{true}{false}\par
+\IfStrEq{}{abc}{true}{false}\par
+\IfStrEq{}{}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfEq}
-
-\verbinline|\IfEq|\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
\begin{Conditions}
- \item The definition of \emph{number} is given with the macro \verbinline|\IfDecimal| (see page~\pageref{ifdecimal}), and thus :
+ \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.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfEq{a1b2c3}{a1b2c3}{true}{false}
-\IfEq{abcdef}{ab}{true}{false}
-\IfEq{ab}{abcdef}{true}{false}
-\IfEq{12.34}{12,34}{true}{false}
-\IfEq{+12.34}{12.340}{true}{false}
-\IfEq{10}{+10}{true}{false}
-\IfEq{-10}{10}{true}{false}
-\IfEq{+0,5}{,5}{true}{false}
-\IfEq{1.001}{1.01}{true}{false}
-\IfEq{3*4+2}{14}{true}{false}
-\IfEq{\number\numexpr3*4+2}{14}{true}{false}
-\IfEq{0}{-0.0}{true}{false}
-\IfEq{}{}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfEq{a1b2c3}{a1b2c3}{true}{false}\par
- \IfEq{abcdef}{ab}{true}{false}\par
- \IfEq{ab}{abcdef}{true}{false}\par
- \IfEq{12.34}{12,34}{true}{false}\par
- \IfEq{+12.34}{12.340}{true}{false}\par
- \IfEq{10}{+10}{true}{false}\par
- \IfEq{-10}{10}{true}{false}\par
- \IfEq{+0,5}{,5}{true}{false}\par
- \IfEq{1.001}{1.01}{true}{false}\par
- \IfEq{3*4+2}{14}{true}{false}\par
- \IfEq{\number\numexpr3*4+2}{14}{true}{false}\par
- \IfEq{0}{-0.0}{true}{false}\par
- \IfEq{}{}{true}{false}
-\end{minipage}%
+\showcode|\IfEq{a1b2c3}{a1b2c3}{true}{false}\par
+\IfEq{abcdef}{ab}{true}{false}\par
+\IfEq{ab}{abcdef}{true}{false}\par
+\IfEq{12.34}{12,34}{true}{false}\par
+\IfEq{+12.34}{12.340}{true}{false}\par
+\IfEq{10}{+10}{true}{false}\par
+\IfEq{-10}{10}{true}{false}\par
+\IfEq{+0,5}{,5}{true}{false}\par
+\IfEq{1.001}{1.01}{true}{false}\par
+\IfEq{3*4+2}{14}{true}{false}\par
+\IfEq{\number\numexpr3*4+2}{14}{true}{false}\par
+\IfEq{0}{-0.0}{true}{false}\par
+\IfEq{}{}{true}{false}|
\subsubsection{\ttfamily\textbackslash IfStrEqCase}
-
\begin{minipage}{\textwidth}
- \verbinline|\IfStrEqCase|\etoile\ARGU{string}\verb|{%|\par
+ \verb|\IfStrEqCase|\etoile\ARGU{string}\verb|{%|\par
\qquad\qquad\ARGU{string1}\ARGU{code1}\verb|%|\par
\qquad\qquad\ARGU{string2}\ARGU{code2}\verb|%|\par
\qquad\qquad\verb|etc...|\par
@@ -530,32 +382,18 @@ 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 \verbinline|\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
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}
-|\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|
-\IfStrEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[other]
-\IfStrEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[other]
-\IfStrEqCase{+3}{{1}{one}{2}{two}{3}{three}}[other]
-\IfStrEqCase{0.5}{{0}{zero}{.5}{half}{1}{one}}[other]
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
- |\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
- \IfStrEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
- \IfStrEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
- \IfStrEqCase{+3}{{1}{one}{2}{two}{3}{three}}[other]\par
- \IfStrEqCase{0.5}{{0}{zero}{.5}{half}{1}{one}}[other]
-\end{minipage}%
+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
-\subsubsection{\ttfamily\textbackslash IfEqCase}
+\showcode-\IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
+|\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
+\IfStrEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
+\IfStrEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
+\IfStrEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[other]\par
+\IfStrEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[other]-
+\subsubsection{\ttfamily\textbackslash IfEqCase}
\begin{minipage}{\textwidth}
- \verbinline|\IfEqCase|\etoile\ARGU{string}\verb|{%|\par
+ \verb|\IfEqCase|\etoile\ARGU{string}\verb|{%|\par
\qquad\qquad\ARGU{string1}\ARGU{code1}\verb|%|\par
\qquad\qquad\ARGU{string2}\ARGU{code2}\verb|%|\par
\qquad\qquad\verb|etc...|\par
@@ -563,32 +401,18 @@ 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 \verbinline|\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
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}
-|\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|
-\IfEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[other]
-\IfEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[other]
-\IfEqCase{+3}{{1}{one}{2}{two}{3}{three}}[other]
-\IfEqCase{0.5}{{0}{zero}{.5}{half}{1}{one}}[other]
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
- |\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
- \IfEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
- \IfEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
- \IfEqCase{+3}{{1}{one}{2}{two}{3}{three}}[other]\par
- \IfEqCase{0.5}{{0}{zero}{.5}{half}{1}{one}}[other]
-\end{minipage}%
+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
+
+\showcode-\IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
+|\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
+\IfEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
+\IfEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[other]\par
+\IfEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[other]\par
+\IfEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[other]-
\subsection{Extraction of substrings}
\subsubsection{\ttfamily\textbackslash StrBefore}
-
-\verbinline|\StrBefore|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
+\verb|\StrBefore|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
\smallskip
The value of the optional argument \argu{number} is 1 by default.\par\smallskip
@@ -601,33 +425,17 @@ In \argu{string}, returns what is leftwards the \argu{number}\th occurrence of \
\item If the occurrence is not found, an empty string is returned.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrBefore{xstring}{tri}
-\StrBefore{LaTeX}{e}
-|\StrBefore{LaTeX}{p}|
-|\StrBefore{LaTeX}{L}|
-|\StrBefore{a bc def }{def}|
-|\StrBefore{a bc def }{cd}|
-\StrBefore[1]{1b2b3}{b}
-\StrBefore[2]{1b2b3}{b}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrBefore{xstring}{tri}\par
- \StrBefore{LaTeX}{e}\par
- |\StrBefore{LaTeX}{p}|\par
- |\StrBefore{LaTeX}{L}|\par
- |\StrBefore{a bc def }{def}|\par
- |\StrBefore{a bc def }{cd}|\par
- \StrBefore[1]{1b2b3}{b}\par
- \StrBefore[2]{1b2b3}{b}
-\end{minipage}%
+\showcode-\StrBefore{xstring}{tri}\par
+\StrBefore{LaTeX}{e}\par
+|\StrBefore{LaTeX}{p}|\par
+|\StrBefore{LaTeX}{L}|\par
+|\StrBefore{a bc def }{def}|\par
+|\StrBefore{a bc def }{cd}|\par
+\StrBefore[1]{1b2b3}{b}\par
+\StrBefore[2]{1b2b3}{b}-
\subsubsection{\ttfamily\textbackslash StrBehind}
-
-\verbinline|\StrBehind|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
+\verb|\StrBehind|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
\smallskip
The value of the optional argument \argu{number} is 1 by default.\par\smallskip
@@ -640,35 +448,19 @@ In \argu{string}, returns what is rightwards the \argu{number}\th occurrence of
\item If the occurrence is not found, an empty string is returned.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrBehind{xstring}{tri}
-\StrBehind{LaTeX}{e}
-|\StrBehind{LaTeX}{p}|
-|\StrBehind{LaTeX}{X}|
-|\StrBehind{a bc def }{bc}|
-|\StrBehind{a bc def }{cd}|
-\StrBehind[1]{1b2b3}{b}
-\StrBehind[2]{1b2b3}{b}
-|\StrBehind[3]{1b2b3}{b}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrBehind{xstring}{tri}\par
- \StrBehind{LaTeX}{e}\par
- |\StrBehind{LaTeX}{p}|\par
- |\StrBehind{LaTeX}{X}|\par
- |\StrBehind{a bc def }{bc}|\par
- |\StrBehind{a bc def }{cd}|\par
- \StrBehind[1]{1b2b3}{b}\par
- \StrBehind[2]{1b2b3}{b}\par
- |\StrBehind[3]{1b2b3}{b}|
-\end{minipage}%
+\showcode-\StrBehind{xstring}{tri}\par
+\StrBehind{LaTeX}{e}\par
+|\StrBehind{LaTeX}{p}|\par
+|\StrBehind{LaTeX}{X}|\par
+|\StrBehind{a bc def }{bc}|\par
+|\StrBehind{a bc def }{cd}|\par
+\StrBehind[1]{1b2b3}{b}\par
+\StrBehind[2]{1b2b3}{b}\par
+|\StrBehind[3]{1b2b3}{b}-
\subsubsection{\ttfamily\textbackslash StrCut}
Here is the syntax of this macro:\par\nobreak\smallskip
-\verbinline|\StrCut|\etoile\arguC{nunber}\ARGU{string}\ARGU{stringA}\ARGU{macroA}\ARGU{macroB}
+\verb|\StrCut|\etoile\arguC{nunber}\ARGU{string}\ARGU{stringA}\ARGU{macroA}\ARGU{macroB}
\smallskip
The optional argument \argu{number} is 1 by default.\par\nobreak\smallskip
@@ -681,38 +473,21 @@ Since this macro returns \emph{two strings}, it does \emph{not} display anything
\item If \argu{number}${}<1$, the macro behaves as if \argu{number}${}=1$;
\item If the occurrence is not found, \argu{macroA} receives the whole \argu{string} while \argu{macroB} is empty.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrCut{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[2]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[3]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[4]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[5]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[6]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[-4]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut{abracadabra}{brac}\csA\csB |\csA|\csB|\par
-\StrCut{abracadabra}{foo}\csA\csB |\csA|\csB|\par
-\StrCut{abracadabra}{}\csA\csB |\csA|\csB|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \def\seprouge{{\color{red}|}}
- \styleexemple
- \StrCut{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[2]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[3]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[5]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[6]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[-4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut{abracadabra}{brac}\csA\csB |\csA\seprouge\csB|\par
- \StrCut{abracadabra}{foo}\csA\csB |\csA\seprouge\csB|\par
- \StrCut{abracadabra}{}\csA\csB |\csA\seprouge\csB|
-\end{minipage}%
-\subsubsection{\ttfamily\textbackslash StrBetween}
+\showcode+\def\seprouge{{\color{red}|}}
+\StrCut{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[2]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[3]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[5]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[6]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[-4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut{abracadabra}{brac}\csA\csB |\csA\seprouge\csB|\par
+\StrCut{abracadabra}{foo}\csA\csB |\csA\seprouge\csB|\par
+\StrCut{abracadabra}{}\csA\csB |\csA\seprouge\csB|+
-\verbinline|\StrBetween|\etoile\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\arguC{name}
+\subsubsection{\ttfamily\textbackslash StrBetween}
+\verb|\StrBetween|\etoile\arguCC{number1}{number2}\ARGU{string}\ARGU{stringA}\ARGU{stringB}\arguC{name}
\smallskip
The values of the optional arguments \argu{number1} and \argu{number2} are 1 by default.\par\smallskip
@@ -725,37 +500,19 @@ In \argu{string}, returns the substring between\footnote{In a strict sense, i.e.
\item If one of the optional arguments \argu{number1} ou \argu{number2} is negative or zero, an empty string is returned.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrBetween{xstring}{xs}{ng}
-|\StrBetween{xstring}{i}{n}|
-|\StrBetween{xstring}{a}{tring}|
-|\StrBetween{a bc def }{a}{d}|
-|\StrBetween{a bc def }{a }{f}|
-\StrBetween{a1b1a2b2a3b3}{a}{b}
-\StrBetween[2,3]{a1b1a2b2a3b3}{a}{b}
-\StrBetween[1,3]{a1b1a2b2a3b3}{a}{b}
-|\StrBetween[3,1]{a1b1a2b2a3b3}{a}{b}|
-\StrBetween[3,2]{abracadabra}{a}{bra}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrBetween{xstring}{xs}{ng}\par
- |\StrBetween{xstring}{i}{n}|\par
- |\StrBetween{xstring}{a}{tring}|\par
- |\StrBetween{a bc def }{a}{d}|\par
- |\StrBetween{a bc def }{a }{f}|\par
- \StrBetween{a1b1a2b2a3b3}{a}{b}\par
- \StrBetween[2,3]{a1b1a2b2a3b3}{a}{b}\par
- \StrBetween[1,3]{a1b1a2b2a3b3}{a}{b}\par
- |\StrBetween[3,1]{a1b1a2b2a3b3}{a}{b}|\par
- \StrBetween[3,2]{abracadabra}{a}{bra}\par
-\end{minipage}%
+\showcode+\StrBetween{xstring}{xs}{ng}\par
+|\StrBetween{xstring}{i}{n}|\par
+|\StrBetween{xstring}{a}{tring}|\par
+|\StrBetween{a bc def }{a}{d}|\par
+|\StrBetween{a bc def }{a }{f}|\par
+\StrBetween{a1b1a2b2a3b3}{a}{b}\par
+\StrBetween[2,3]{a1b1a2b2a3b3}{a}{b}\par
+\StrBetween[1,3]{a1b1a2b2a3b3}{a}{b}\par
+|\StrBetween[3,1]{a1b1a2b2a3b3}{a}{b}|\par
+\StrBetween[3,2]{abracadabra}{a}{bra}+
\subsubsection{\ttfamily\textbackslash StrSubstitute}
-
-\verbinline|\StrSubstitute|\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
@@ -770,37 +527,19 @@ In \argu{string}, substitute the \argu{number} first occurrences of \argu{string
\item If \argu{stringB} is empty, the occurrences of \argu{stringA}, if they exist, are deleted.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrSubstitute{xstring}{i}{a}
-\StrSubstitute{abracadabra}{a}{o}
-\StrSubstitute{abracadabra}{br}{TeX}
-\StrSubstitute{LaTeX}{m}{n}
-\StrSubstitute{a bc def }{ }{M}
-\StrSubstitute{a bc def }{ab}{AB}
-\StrSubstitute[1]{a1a2a3}{a}{B}
-\StrSubstitute[2]{a1a2a3}{a}{B}
-\StrSubstitute[3]{a1a2a3}{a}{B}
-\StrSubstitute[4]{a1a2a3}{a}{B}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrSubstitute{xstring}{i}{a}\par
- \StrSubstitute{abracadabra}{a}{o}\par
- \StrSubstitute{abracadabra}{br}{TeX}\par
- \StrSubstitute{LaTeX}{m}{n}\par
- \StrSubstitute{a bc def }{ }{M}\par
- \StrSubstitute{a bc def }{ab}{AB}\par
- \StrSubstitute[1]{a1a2a3}{a}{B}\par
- \StrSubstitute[2]{a1a2a3}{a}{B}\par
- \StrSubstitute[3]{a1a2a3}{a}{B}\par
- \StrSubstitute[4]{a1a2a3}{a}{B}
-\end{minipage}%
+\showcode|\StrSubstitute{xstring}{i}{a}\par
+\StrSubstitute{abracadabra}{a}{o}\par
+\StrSubstitute{abracadabra}{br}{TeX}\par
+\StrSubstitute{LaTeX}{m}{n}\par
+\StrSubstitute{a bc def }{ }{M}\par
+\StrSubstitute{a bc def }{ab}{AB}\par
+\StrSubstitute[1]{a1a2a3}{a}{B}\par
+\StrSubstitute[2]{a1a2a3}{a}{B}\par
+\StrSubstitute[3]{a1a2a3}{a}{B}\par
+\StrSubstitute[4]{a1a2a3}{a}{B}|
\subsubsection{\ttfamily\textbackslash StrDel}
-
-\verbinline|\StrDel|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
+\verb|\StrDel|\etoile\arguC{number}\ARGU{string}\ARGU{stringA}\arguC{name}
\smallskip
The value of the optional argument \argu{number} is 0 by default.\par\smallskip
@@ -814,28 +553,15 @@ Delete the \argu{number} first occurrences of \argu{stringA} in \argu{string}, e
\item If \argu{number}${}<0$ the macro behaves as if \argu{number}${}=0$;
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrDel{abracadabra}{a}
-\StrDel[1]{abracadabra}{a}
-\StrDel[4]{abracadabra}{a}
-\StrDel[9]{abracadabra}{a}
-\StrDel{a bc def }{ }
-|\StrDel{a bc def }{def}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrDel{abracadabra}{a}\par
- \StrDel[1]{abracadabra}{a}\par
- \StrDel[4]{abracadabra}{a}\par
- \StrDel[9]{abracadabra}{a}\par
- \StrDel{a bc def }{ }\par
- |\StrDel{a bc def }{def}|
-\end{minipage}%
+\showcode+\StrDel{abracadabra}{a}\par
+\StrDel[1]{abracadabra}{a}\par
+\StrDel[4]{abracadabra}{a}\par
+\StrDel[9]{abracadabra}{a}\par
+\StrDel{a bc def }{ }\par
+|\StrDel{a bc def }{def}|+
\subsubsection{\ttfamily\textbackslash StrGobbleLeft}
-\verbinline|\StrGobbleLeft|\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
@@ -846,27 +572,14 @@ In \argu{string}, delete the \argu{number} first characters on the left.\medskip
\item If \argu{number}${}\geqslant{}$\argu{lengthString}, all the characters are deleted.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrGobbleLeft{xstring}{2}
-|\StrGobbleLeft{xstring}{9}|
-\StrGobbleLeft{LaTeX}{4}
-\StrGobbleLeft{LaTeX}{-2}
-|\StrGobbleLeft{a bc def }{4}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrGobbleLeft{xstring}{2}\par
- |\StrGobbleLeft{xstring}{9}|\par
- \StrGobbleLeft{LaTeX}{4}\par
- \StrGobbleLeft{LaTeX}{-2}\par
- |\StrGobbleLeft{a bc def }{4}|
-\end{minipage}%
+\showcode+\StrGobbleLeft{xstring}{2}\par
+|\StrGobbleLeft{xstring}{9}|\par
+\StrGobbleLeft{LaTeX}{4}\par
+\StrGobbleLeft{LaTeX}{-2}\par
+|\StrGobbleLeft{a bc def }{4}|+
\subsubsection{\ttfamily\textbackslash StrLeft}
-
-\verbinline|\StrLeft|\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
@@ -877,77 +590,38 @@ In \argu{string}, returns the \argu{number} first characters on the left.\medski
\item If \argu{number}${}\geqslant{}$\argu{lengthString}, all the characters are returned.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrLeft{xstring}{2}
-\StrLeft{xstring}{9}
-\StrLeft{LaTeX}{4}
-|\StrLeft{LaTeX}{-2}|
-|\StrLeft{a bc def }{5}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrLeft{xstring}{2}\par
- \StrLeft{xstring}{9}\par
- \StrLeft{LaTeX}{4}\par
- |\StrLeft{LaTeX}{-2}|\par
- |\StrLeft{a bc def }{5}|
-\end{minipage}%
+\showcode+\StrLeft{xstring}{2}\par
+\StrLeft{xstring}{9}\par
+\StrLeft{LaTeX}{4}\par
+|\StrLeft{LaTeX}{-2}|\par
+|\StrLeft{a bc def }{5}|+
\subsubsection{\ttfamily\textbackslash StrGobbleRight}
-
-\verbinline|\StrGobbleRight|\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
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrGobbleRight{xstring}{2}
-|\StrGobbleRight{xstring}{9}|
-\StrGobbleRight{LaTeX}{4}
-|\StrGobbleRight{LaTeX}{-2}|
-|\StrGobbleRight{a bc def }{4}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrGobbleRight{xstring}{2}\par
- |\StrGobbleRight{xstring}{9}|\par
- \StrGobbleRight{LaTeX}{4}\par
- |\StrGobbleRight{LaTeX}{-2}|\par
- |\StrGobbleRight{a bc def }{4}|
-\end{minipage}%
+\showcode+\StrGobbleRight{xstring}{2}\par
+|\StrGobbleRight{xstring}{9}|\par
+\StrGobbleRight{LaTeX}{4}\par
+|\StrGobbleRight{LaTeX}{-2}|\par
+|\StrGobbleRight{a bc def }{4}|+
\subsubsection{\ttfamily\textbackslash StrRight}
-
-\verbinline|\StrRight|\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
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrRight{xstring}{2}
-\StrRight{xstring}{9}
-\StrRight{LaTeX}{4}
-|\StrRight{LaTeX}{-2}|
-\StrRight{a bc def }{5}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrRight{xstring}{2}\par
- \StrRight{xstring}{9}\par
- \StrRight{LaTeX}{4}\par
- |\StrRight{LaTeX}{-2}|\par
- \StrRight{a bc def }{5}
-\end{minipage}%
+\showcode+\StrRight{xstring}{2}\par
+\StrRight{xstring}{9}\par
+\StrRight{LaTeX}{4}\par
+|\StrRight{LaTeX}{-2}|\par
+\StrRight{a bc def }{5}+
\subsubsection{\ttfamily\textbackslash StrChar}
-
-\verbinline|\StrChar|\etoile\ARGU{string}\ARGU{number}\arguC{name}
+\verb|\StrChar|\etoile\ARGU{string}\ARGU{number}\arguC{name}
\smallskip
Returns the \US at the position \argu{number} in \argu{string}.\medskip
@@ -957,25 +631,13 @@ Returns the \US at the position \argu{number} in \argu{string}.\medskip
\item If \argu{number}${}\leqslant0$ or if \argu{number}${}>{}$\argu{lengthString}, no character is returned.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrChar{xstring}{4}
-|\StrChar{xstring}{9}|
-|\StrChar{xstring}{-5}|
-\StrChar{a bc def }{6}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrChar{xstring}{4}\par
- |\StrChar{xstring}{9}|\par
- |\StrChar{xstring}{-5}|\par
- \StrChar{a bc def }{6}
-\end{minipage}%
+\showcode+\StrChar{xstring}{4}\par
+|\StrChar{xstring}{9}|\par
+|\StrChar{xstring}{-5}|\par
+\StrChar{a bc def }{6}+
\subsubsection{\ttfamily\textbackslash StrMid}
-
-\verbinline|\StrMid|\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
@@ -989,51 +651,26 @@ In \argu{string}, returns the substring between\footnote{In the broad sense, i.e
\item If \argu{numberB}${}>{}$\argu{lengthString}, the macro behaves as if \argu{numberB}${}={}$\argu{lengthString}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrMid{xstring}{2}{5}
-\StrMid{xstring}{-4}{2}
-|\StrMid{xstring}{5}{1}|
-\StrMid{xstring}{6}{15}
-\StrMid{xstring}{3}{3}
-|\StrMid{a bc def }{2}{7}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrMid{xstring}{2}{5}\par
- \StrMid{xstring}{-4}{2}\par
- |\StrMid{xstring}{5}{1}|\par
- \StrMid{xstring}{6}{15}\par
- \StrMid{xstring}{3}{3}\par
- |\StrMid{a bc def }{2}{7}|
-\end{minipage}%
+\showcode+\StrMid{xstring}{2}{5}\par
+\StrMid{xstring}{-4}{2}\par
+|\StrMid{xstring}{5}{1}|\par
+\StrMid{xstring}{6}{15}\par
+\StrMid{xstring}{3}{3}\par
+|\StrMid{a bc def }{2}{7}|+
\subsection{Macros returning a number}
\subsubsection{\ttfamily\textbackslash StrLen}
-
-\verbinline|\StrLen|\ARGU{string}\arguC{name}
+\verb|\StrLen|\ARGU{string}\arguC{name}
\smallskip
Return the length of \argu{string}.
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrLen{xstring}
-\StrLen{A}
-\StrLen{a bc def }
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrLen{xstring}\par
- \StrLen{A}\par
- \StrLen{a bc def }
-\end{minipage}%
+\showcode+\StrLen{xstring}\par
+\StrLen{A}\par
+\StrLen{a bc def }+
\subsubsection{\ttfamily\textbackslash StrCount}
-
-\verbinline|\StrCount|\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
@@ -1042,25 +679,13 @@ Counts how many times \argu{stringA} is contained in \argu{string}.\par\medskip
\item If one at least of the arguments \argu{string} or \argu{stringA} is empty, the macro return 0.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrCount{abracadabra}{a}
-\StrCount{abracadabra}{bra}
-\StrCount{abracadabra}{tic}
-\StrCount{aaaaaa}{aa}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrCount{abracadabra}{a}\par
- \StrCount{abracadabra}{bra}\par
- \StrCount{abracadabra}{tic}\par
- \StrCount{aaaaaa}{aa}
-\end{minipage}%
+\showcode+\StrCount{abracadabra}{a}\par
+\StrCount{abracadabra}{bra}\par
+\StrCount{abracadabra}{tic}\par
+\StrCount{aaaaaa}{aa}+
\subsubsection{\ttfamily\textbackslash StrPosition}
-
-\verbinline|\StrPosition|\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
@@ -1073,111 +698,66 @@ In \argu{string}, returns the position of the \argu{number}\th occurrence of \ar
\end{Conditions}
\medskip
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrPosition{xstring}{ring}
-\StrPosition[4]{abracadabra}{a}
-\StrPosition[2]{abracadabra}{bra}
-\StrPosition[9]{abracadabra}{a}
-\StrPosition{abracadabra}{z}
-\StrPosition{a bc def }{d}
-\StrPosition[3]{aaaaaa}{aa}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrPosition{xstring}{ring}\par
- \StrPosition[4]{abracadabra}{a}\par
- \StrPosition[2]{abracadabra}{bra}\par
- \StrPosition[9]{abracadabra}{a}\par
- \StrPosition{abracadabra}{z}\par
- \StrPosition{a bc def }{d}\par
- \StrPosition[3]{aaaaaa}{aa}
-\end{minipage}%
+\showcode+\StrPosition{xstring}{ring}\par
+\StrPosition[4]{abracadabra}{a}\par
+\StrPosition[2]{abracadabra}{bra}\par
+\StrPosition[9]{abracadabra}{a}\par
+\StrPosition{abracadabra}{z}\par
+\StrPosition{a bc def }{d}\par
+\StrPosition[3]{aaaaaa}{aa}+
\subsubsection{\ttfamily\textbackslash StrCompare}
-\verbinline|\StrCompare|\etoile\ARGU{stringA}\ARGU{stringB}\arguC{name}
+\verb|\StrCompare|\etoile\ARGU{stringA}\ARGU{stringB}\arguC{name}
\smallskip
This macro has 2 tolerances: the "normal" tolerance, used by default, and the "strict" tolerance.
+
\begin{itemize}
- \item The normal tolerance is activated with \verbinline|\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 is activated with \verbinline|\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
-It is possible to save the comparison mode with \verbinline|\savecomparemode|, then modify this comparison mode and come back to the situation when it was saved with \verbinline|\restorecomparemode|.\medskip
+It is possible to save the comparison mode with \verb|\savecomparemode|, then modify this comparison mode and come back to the situation when it was saved with \verb|\restorecomparemode|.\medskip
Examples with the normal tolerance:\par\nobreak
-\begin{minipage}[t]{0.65\linewidth}
+\showcode+
\comparenormal
-\begin{lstlisting}
-\StrCompare{abcd}{abcd}
-\StrCompare{abcd}{abc}
-\StrCompare{abc}{abcd}
-\StrCompare{a b c}{abc}
-\StrCompare{aaa}{baaa}
-\StrCompare{abc}{xyz}
-\StrCompare{123456}{123457}
-\StrCompare{abc}{}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \comparenormal
- \StrCompare{abcd}{abcd}\par
- \StrCompare{abcd}{abc}\par
- \StrCompare{abc}{abcd}\par
- \StrCompare{a b c}{abc}\par
- \StrCompare{aaa}{baaa}\par
- \StrCompare{abc}{xyz}\par
- \StrCompare{123456}{123457}\par
- \StrCompare{abc}{}
-\end{minipage}%
-\medskip
+\StrCompare{abcd}{abcd}\par
+\StrCompare{abcd}{abc}\par
+\StrCompare{abc}{abcd}\par
+\StrCompare{a b c}{abc}\par
+\StrCompare{aaa}{baaa}\par
+\StrCompare{abc}{xyz}\par
+\StrCompare{123456}{123457}\par
+\StrCompare{abc}{}+
Examples with the strict tolerance:\par\nobreak
-\begin{minipage}[t]{0.65\linewidth}
-\comparestrict
-\begin{lstlisting}
-\StrCompare{abcd}{abcd}
-\StrCompare{abcd}{abc}
-\StrCompare{abc}{abcd}
-\StrCompare{a b c}{abc}
-\StrCompare{aaa}{baaa}
-\StrCompare{abc}{xyz}
-\StrCompare{123456}{123457}
-\StrCompare{abc}{}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \comparestrict
- \StrCompare{abcd}{abcd}\par
- \StrCompare{abcd}{abc}\par
- \StrCompare{abc}{abcd}\par
- \StrCompare{a b c}{abc}\par
- \StrCompare{aaa}{baaa}\par
- \StrCompare{abc}{xyz}\par
- \StrCompare{123456}{123457}\par
- \StrCompare{abc}{}
-\end{minipage}%
+\showcode+\comparestrict
+\StrCompare{abcd}{abcd}\par
+\StrCompare{abcd}{abc}\par
+\StrCompare{abc}{abcd}\par
+\StrCompare{a b c}{abc}\par
+\StrCompare{aaa}{baaa}\par
+\StrCompare{abc}{xyz}\par
+\StrCompare{123456}{123457}\par
+\StrCompare{abc}{}+
\section{Operating modes}
\subsection{Expansion of arguments}
\label{devarg}
\subsubsection{The commands {\ttfamily \textbackslash fullexpandarg}, {\ttfamily \textbackslash expandarg} and {\ttfamily \textbackslash noexpandarg}}
-The command \verbinline|\fullexpandarg| is called by default, so all the arguments are fully expanded (an \verbinline|\edef| is used) before the the macro works on them. In most of the cases, this expansion mode avoids chains of \verbinline|\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 commands \verbinline|\noexpandarg| or \verbinline|\normalexpandarg|.\medskip
+Of course, the expansion of argument can be canceled to find back the usual behaviour of \TeX{} with the commands \verb|\noexpandarg| or \verb|\normalexpandarg|.\medskip
-Another expansion mode can be called with \verbinline|\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 \verbinline|\StrExpand|, 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|\StrExpand|, see page~\pageref{scancs}).\medskip
-The commands \verbinline|\fullexpandarg|, \verbinline|\noexpandarg|, \verbinline|\normalexpandarg| and \verbinline|\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" and they can be locally used in a group.\medskip
-It is possible to save the expansion mode with \verbinline|\saveexpandmode|, then modify this expansion mode and come back to the situation when it was saved with \verbinline|\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|.\medskip
In the following list, for every macro of the previous chapter, the arguments colored in \textcolor{violet}{purple} will possibly be expanded, according to the expansion mode:\smallskip
@@ -1224,7 +804,7 @@ In the following list, for every macro of the previous chapter, the arguments co
\subsubsection{Chars and tokens 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 future version.}.\bigskip
-When full expansion mode is activated with \verbinline|\fullexpandarg|, arguments are expanded with an \verbinline|\edef| before they are read by the macro. Consequently, are allowed in arguments:
+When full expansion mode is activated with \verb|\fullexpandarg|, arguments are expanded with an \verb|\edef| before they are read by the macro. Consequently, are allowed in arguments:
\parindent3em
\begin{itemize}
\item letters (uppercase or lowercase, accented\footnote{For a reliable operation with accented letters, the \texttt{\string\fontenc} package with option \texttt{[T1]} and \texttt{\string\inputenc} with appropriated option must be loaded} or not), figures, spaces, and any other character with a catcode of 10, 11 ou 12 (punctuation signs, calculation signs, parenthesis, square bracket, etc).;
@@ -1232,43 +812,34 @@ When full expansion mode is activated with \verbinline|\fullexpandarg|, argument
\item tokens with catcode 7 and 8, usually : \verb|^|\quad\verb|_|
\item any purely expandable control sequence\footnote{i.e. this control sequence can be {\ttfamily\string\edef}ed.} or tokens with catcode 13 (active chars) whose expansion is allowed chars.
\end{itemize}\parindent0pt
-\smallskip
+\parindent0pt\smallskip
-When arguments are not expanded with the use of \verbinline|\noexpandarg|, other tokens can be put in a string whatever be the code they make: any control sequence, even undefined, any token catcode 13. Moreover, test tokens are allowed like \verbinline|\if| or \verbinline|\ifx|, even without their \verbinline|\fi|. On the same way, a \verbinline|\csname| without its \verbinline|\endcsname| is allowed.
+When arguments are not expanded with the use of \verb|\noexpandarg|, other tokens can be put in a string whatever be the code they make: any control sequence, even undefined, any token catcode 13. Moreover, test tokens are allowed like \verb|\if| or \verb|\ifx|, even without their \verb|\fi|. On the same way, a \verb|\csname| without its \verb|\endcsname| is allowed.
-In this example, the argument contains a \verbinline|\ifx| \emph{without} the \verbinline|\fi|: the \verbinline|\StrBetween| command extracts and dislpays what is between \verbinline|\ifx| and \verbinline|\else|:\par\medskip\nobreak
+In this example, the argument contains a \verb|\ifx| \emph{without} the \verb|\fi|: the \verb|\StrBetween| command extracts and dislpays what is between \verb|\ifx| and \verb|\else|:\par\medskip\nobreak
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
-\StrBetween{\ifx ab false \else true}{\ifx}{\else}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \StrBetween{\ifx ab false \else true}{\ifx}{\else}
-\end{minipage}
+\showcode+\noexpandarg
+\StrBetween{\ifx ab false \else true}{\ifx}{\else}+
\medskip
-When \verbinline|\expandarg| is used, the first token needs precaution since it is expanded one time: it must be defined. The other tokens are left unchanged like with \verbinline|\noexpandarg|.
+When \verb|\expandarg| is used, the first token needs precaution since it is expanded one time: it must be defined. The other tokens are left unchanged like with \verb|\noexpandarg|.
\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 \verbinline|\edef|. Nestling macros is not possible neither.\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) 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 \verbinline|\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\nobreak
-\hspace{0.2\linewidth}\verbinline|\edef\Result{\StrLeft{xstring}{4}}|\par\nobreak
+\hspace{0.2\linewidth}\verb|\edef\Result{\StrLeft{xstring}{4}}|\par\nobreak
\qquad is equivalent to :\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrLeft{xstring}{4}[\Result]|\medskip
+\hspace{0.2\linewidth}\verb|\StrLeft{xstring}{4}[\Result]|\medskip
And this nested structure, not allowed neither, supposed to remove the first and last char of \verb|xstring|:\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrGobbleLeft{\StrGobbleRight{xstring}{1}}{1}|\par\nobreak
+\hspace{0.2\linewidth}\verb|\StrGobbleLeft{\StrGobbleRight{xstring}{1}}{1}|\par\nobreak
\qquad should be written like this:\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrGobbleRight{xstring}{1}[\mystring]|\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrGobbleleft{\mystring}{1}|\par
+\hspace{0.2\linewidth}\verb|\StrGobbleRight{xstring}{1}[\mystring]|\par\nobreak
+\hspace{0.2\linewidth}\verb|\StrGobbleleft{\mystring}{1}|\par
\subsection{How does \Xstring read the arguments?}
\label{developpementarguments}
@@ -1285,111 +856,68 @@ 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 if, while \verbinline|\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}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
+\showcode+\noexpandarg
\StrLen{ab\textbf{xyz}cd}\par
\StrChar{ab\textbf{xyz}cd}{4}[\mychar]
-\meaning\mychar
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \StrLen{ab\textbf{xyz}cd}\par
- \StrChar{ab\textbf{xyz}cd}{4}[\mychar]
- \meaning\mychar
-\end{minipage}%
+\meaning\mychar+
\fullexpandarg
\medskip
-It is necessary to use \verbinline|\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.
+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 \verbinline|\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.
+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: \verbinline|\exploregroups| changes the exploration mode and forces the macros to 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 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
\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
+\showcode+\noexpandarg
\exploregroups
\StrLen{ab\textbf{xyz}cd}\par
\StrChar{ab\textbf{xyz}cd}{4}[\mychar]
-\meaning\mychar
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \exploregroups
- \StrLen{ab\textbf{xyz}cd}\par
- \StrChar{ab\textbf{xyz}cd}{4}[\mychar]
- \meaning\mychar
-\end{minipage}%
+\meaning\mychar+
\fullexpandarg\noexploregroups
\medskip
-Exploring the groups can be usefull for counting a substring in a string (\verbinline|\StrCount|), for the position of a substring in a string (\verbinline|\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
+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:\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
+
+\showcode+\noexpandarg
\exploregroups
\StrBefore[2]{\a1{\b1\a2}\a3}{\a}[\mycs]
-\meaning\mycs
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \exploregroups
- \StrBefore[2]{\a1{\b1\a2}\a3}{\a}[\mycs]
- \meaning\mycs
-\end{minipage}%
-\medskip
+\meaning\mycs+
-Exploring the groups\footnote{The file test of \Xstring has many examples underlining differences between exploration modes.} can change the behaviour of most of the macros of \Xstring, excepted these macros untouched by the exploration mode; their behaviour is the same in any case: \verbinline|\IfInteger|, \verbinline|\IfDecimal|, \verbinline|\IfStrEq|, \verbinline|\StrEq| et \verbinline|\StrCompare|.
+Exploring the groups\footnote{The file test of \Xstring has many examples underlining differences between exploration modes.} can change the behaviour of most of the macros of \Xstring, excepted these macros untouched by the exploration mode; their behaviour is the same in any case: \verb|\IfInteger|, \verb|\IfDecimal|, \verb|\IfStrEq|, \verb|\StrEq| et \verb|\StrCompare|.
-Moreover, 2 macros run in \verbinline|\noexploregroups| mode, whatever be the current mode: \verbinline|\StrBetween| et \verbinline|\StrMid|.\medskip
+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 exploration mode with \verbinline|\saveexploremode|, then modify it and come back to the situation when it was saved with \verbinline|\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 and starred macros}
\label{macrosetoilees}
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\verbinline|{\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 \verbinline|\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 \verbinline|\string| whose expansions are a strings with chars catcodes 12 and 10 : \verbinline|\detokenize|, \verbinline|\meaning|, \verbinline|\jobname|, \verbinline|\fontname|, \verbinline|\romannumeral|, etc.\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 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 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\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\IfStrEq{\string a\string b}{ab}{true}{false}\par
-\IfStrEq*{\string a\string b}{ab}{true}{false}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \IfStrEq{\string a\string b}{ab}{true}{false}\par
- \IfStrEq*{\string a\string b}{ab}{true}{false}
-\end{minipage}%
+\showcode+\IfStrEq{\string a\string b}{ab}{true}{false}\par
+\IfStrEq*{\string a\string b}{ab}{true}{false}+
\smallskip
The strings do not match because of catcode differences: the test is negative in the non-starred macro.\bigskip
\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 "\verbinline|\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
+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{violet}{purple} arguments will be detokenized:\smallskip
@@ -1423,9 +951,9 @@ The macro with a starred version are listed below. For these macros, if starred
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 \verbinline=\exploregroups= mode is active, the macro \verbinline=\StrFindGroup= finds a group between braces with its identifier:\smallskip
+When \verb=\exploregroups= mode is active, the macro \verb=\StrFindGroup= finds a group between braces with its identifier:\smallskip
-\verbinline|\StrFindGroup|\ARGU{argument}\ARGU{identifier}\arguC{name}\medskip
+\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
@@ -1440,7 +968,9 @@ Let's take an example with 3 levels of nestled groups. In this example, braces d
\[\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
+In this example:
+
+\nobreak\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}
@@ -1450,45 +980,25 @@ In this example:\parindent3em
\parindent0pt
\medskip
Here is the full example:\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\exploregroups
+\showcode+\exploregroups
\expandarg
-\def\mystring{a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}}
-\StrFindGroup{\mystring}{1}[\mygroup]
-\meaning\mygroup\par
-\StrFindGroup{\mystring}{2,1}[\mygroup]
-\meaning\mygroup\par
-\StrFindGroup{\mystring}{2,3,2}[\mygroup]
-\meaning\mygroup\par
-\StrFindGroup{\mystring}{2,5}[\mygroup]
-\meaning\mygroup\par
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \exploregroups
- \expandarg
- \def\mystring{a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}}
- \StrFindGroup{\mystring}{1}[\mygroup]
- \meaning\mygroup\par
- \StrFindGroup{\mystring}{2,1}[\mygroup]
- \meaning\mygroup\par
- \StrFindGroup{\mystring}{2,3,2}[\mygroup]
- \meaning\mygroup\par
- \StrFindGroup{\mystring}{2,5}[\mygroup]
- \meaning\mygroup\par
-\end{minipage}%
+\def\chaine{a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}}
+\StrFindGroup{\chaine}{1}[\mongroupe]
+\meaning\mongroupe\par
+\StrFindGroup{\chaine}{2,1}[\mongroupe]
+\meaning\mongroupe\par
+\StrFindGroup{\chaine}{2,3,2}[\mongroupe]
+\meaning\mongroupe\par
+\StrFindGroup{\chaine}{2,5}[\mongroupe]
+\meaning\mongroupe+
\bigskip
-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: \verbinline|\IfSubStr|, \verbinline|\StrBefore|, \verbinline|\StrBehind|, \verbinline|\StrSplit|, \verbinline|\StrLeft|, \verbinline|\StrGobbleLeft|, \verbinline|\StrRight|, \verbinline|\StrGobbleRight|, \verbinline|\StrChar|, \verbinline|\StrPosition|.\medskip
+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 \verbinline|\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, \verbinline|\groupID| is empty. Obvioulsly, the use of \verbinline|\groupID| has sense only when \verbinline|\exploregroups| mode is acive and when non starred macros are used.\smallskip
+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 \verbinline|\StrChar|:\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\exploregroups
+Here are some examples with the macro \verb|\StrChar|:\par\nobreak\smallskip
+\showcode+\exploregroups
char 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
\string\groupID = \groupID\par
char 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
@@ -1496,27 +1006,13 @@ char 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
char 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
\string\groupID = \groupID\par
char 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
-\string\groupID = \groupID
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \exploregroups
- char 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
- \string\groupID = \groupID\par
- char 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
- \string\groupID = \groupID\par
- char 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
- \string\groupID = \groupID\par
- char 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
- \string\groupID = \groupID
-\end{minipage}
+\string\groupID = \groupID+
\subsection{Splitting a string, the macro {\ttfamily\textbackslash StrSplit}}
\label{StrSplit}
Here is the syntax:\smallskip
-\verbinline|\StrSplit|\ARGU{string}\ARGU{number}\ARGU{stringA}\ARGU{stringB}
+\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
@@ -1528,54 +1024,23 @@ This macro returns two strings, so it does \emph{not} display anything. Conseque
\item If \argu{string} is empty, \argu{stringA} and \argu{stringB} are empty, whatever be the integer \argu{number}.
\end{Conditions}
-\begin{minipage}[c]{0.65\linewidth}
-
-\begin{lstlisting}
-\def\redsep{{\color{red}|}}%
-\StrSplit{abcdef}{4}{\csA}{\csB}|\csA\redsep\csB|
-\StrSplit{a b c }{2}{\csA}{\csB}|\csA\redsep\csB|
-\StrSplit{abcdef}{1}{\csA}{\csB}|\csA\redsep\csB|
-\StrSplit{abcdef}{5}{\csA}{\csB}|\csA\redsep\csB|
-\StrSplit{abcdef}{9}{\csA}{\csB}|\csA\redsep\csB|
-\StrSplit{abcdef}{-3}{\csA}{\csB}|\csA\redsep\csB|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \def\redsep{{\color{red}|}}%
- \StrSplit{abcdef}{4}{\csA}{\csB}|\csA\redsep\csB|\par
- \StrSplit{a b c }{2}{\csA}{\csB}|\csA\redsep\csB|\par
- \StrSplit{abcdef}{1}{\csA}{\csB}|\csA\redsep\csB|\par
- \StrSplit{abcdef}{5}{\csA}{\csB}|\csA\redsep\csB|\par
- \StrSplit{abcdef}{9}{\csA}{\csB}|\csA\redsep\csB|\par
- \StrSplit{abcdef}{-3}{\csA}{\csB}|\csA\redsep\csB|
-\end{minipage}%
+\showcode+\def\seprouge{{\color{red}|}}
+\StrSplit{abcdef}{4}{\csA}{\csB}|\csA\seprouge\csB|\par
+\StrSplit{a b c }{2}{\csA}{\csB}|\csA\seprouge\csB|\par
+\StrSplit{abcdef}{1}{\csA}{\csB}|\csA\seprouge\csB|\par
+\StrSplit{abcdef}{5}{\csA}{\csB}|\csA\seprouge\csB|\par
+\StrSplit{abcdef}{9}{\csA}{\csB}|\csA\seprouge\csB|\par
+\StrSplit{abcdef}{-3}{\csA}{\csB}|\csA\seprouge\csB|+
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:\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\hfill
-\begin{lstlisting}
-\exploregroups
+\showcode+\exploregroups
\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
-\meaning\strB
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \exploregroups
- \StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
- \meaning\strA\par
- \meaning\strB
-\end{minipage}%
-\medskip
+\meaning\strB+\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, \verbinline|\StrSplit| closes as many group as necessary until it finds the next \US: the cut is made just before this \US.\smallskip
+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}[c]{0.65\linewidth}
-\hfill
-\begin{lstlisting}
-\exploregroups
+\showcode+\exploregroups
Use without star :\par
\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
@@ -1585,36 +1050,20 @@ Use with star :\par
\StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
\meaning\strB\par
-\string\groupID\ = \groupID
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \exploregroups
- Use without star :\par
- \StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
- \meaning\strA\par
- \meaning\strB\par
- \string\groupID\ = \groupID\par\medskip
- Use with star :\par
- \StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
- \meaning\strA\par
- \meaning\strB\par
- \string\groupID\ = \groupID
-\end{minipage}%
+\string\groupID\ = \groupID+
\subsection{Assign a verb content, the macro \ttfamily\textbackslash verbtocs}
\label{verbtocs}
-The macro \verbinline|\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:\par\nobreak\medskip
-\hfill\verbinline|\verbtocs|\ARGU{name}|\argu{characters}|\hfill{}
+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:\par\nobreak\medskip
+\hfill\verb|\verbtocs|\ARGU{name}|\argu{characters}|\hfill{}
\smallskip
-\argu{name} is the name of the control sequence receiving, with an \verbinline|\edef|, the \argu{characters}. \argu{name} thus contains tokens 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 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\nobreak\medskip
-\hfill\verbinline|\setverbdelim|\ARGU{character}\hfill{}\smallskip
+\hfill\verb|\setverbdelim|\ARGU{character}\hfill{}\smallskip
-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 \verbinline|\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}
@@ -1624,117 +1073,74 @@ About verb arguments, keep in mind that:
\medskip
Example:\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\lstset{deletecomment=[l]\%}
-\begin{lstlisting}
-\verbtocs{\result} |a & b{ c% d$ e \f|
-I display the result :\par\result
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\result} |a & b{ c% d$ e \f|
- I display the result :\par\result
-\end{minipage}%
+\showcode+\verbtocs{\resultat} |a & b{ c% d$ e \f|
+here is the result:\par\resultat+
\subsection{Tokenization of a text to a control sequence, the macro \ttfamily\textbackslash tokenize}
The reverse process of what has been seen above is to transform chars into tokens. This is done by the macro:\par\nobreak\medskip
-\hfill\verbinline|\tokenize|\ARGU{name}\ARGU{control sequences}\hfill{}
+\hfill\verb|\tokenize|\ARGU{name}\ARGU{control sequences}\hfill{}
\smallskip
-\argu{control sequences} is fully expanded if \verbinline|\fullexpandarg| has been called, and is not expanded if \verbinline|\noexpandarg| or \verbinline|\expandarg| are active. After expansion, the chars are tokenized to tokens and assigned to \argu{name} with a \verbinline|\def|.\medskip
+\argu{control sequences} is fully expanded if \verb|\fullexpandarg| has been called, and is not expanded if \verb|\noexpandarg| or \verb|\expandarg| are active. After expansion, the chars are tokenized to tokens and assigned to \argu{name} with a \verb|\def|.\medskip
Example:\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\verbtocs{\text}|\textbf{a} $\frac{1}{2}$|
+\showcode+\verbtocs{\text}|\textbf{a} $\frac{1}{2}$|
text : \text
-\tokenize{\result}{\text}\par
-result : \result
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\text}
- |\textbf{a} $\frac{1}{2}$|
- text : \text
- \tokenize{\result}{\text} \par
- result : \result
-\end{minipage}%
+\tokenize{\resultat}{\text}\par
+result : \resultat+
\medskip
Obviously, the control sequence \verb|\result| can be called at the last line since the control sequences it contains are defined.
\subsection{Expansion of a control sequence before verbatimize, the macros {\ttfamily\textbackslash StrExpand} and {\ttfamily\textbackslash scancs}}
\label{scancs}
-The macro \verbinline|\StrExpand| expands the tokens of a string:\par\nobreak\medskip
-\verbinline|\StrExpand|\arguC{number}\ARGU{string}\ARGU{name}\smallskip
+The macro \verb|\StrExpand| expands the tokens of a string:\par\nobreak\medskip
+\verb|\StrExpand|\arguC{number}\ARGU{string}\ARGU{name}\smallskip
By default, \argu{number} is 1 and represnts the number of times each token of \argu{string} has to be expanded. The \argu{name} is a control sequence receiving the result of the expansions.\medskip
Macro works sequentially and by pass: in a pass, each token from left to right is replaced by its 1-expansion. After this expansion, if the \argu{number} of expansions is not reached, an other pass starts, and so on.\medskip
Here is an example:\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\def\csA{1 2}
+\showcode+\def\csA{1 2}
\def\csB{a \csA}
\def\csC{\csB\space}
\def\csD{x{\csA y}\csB{\csC z}}
-Expansion of \string\csD\ at\par
-\StrExpand[0]{\csD}{\csE} depth 0 :
+Expansion of \string\csD\ au\par
+\StrExpand[0]{\csD}{\csE} level 0 :
\detokenize\expandafter{\csE}\par
-\StrExpand[1]{\csD}{\csE} depth 1 :
+\StrExpand[1]{\csD}{\csE} level 1 :
\detokenize\expandafter{\csE}\par
-\StrExpand[2]{\csD}{\csE} depth 2 :
+\StrExpand[2]{\csD}{\csE} level 2 :
\detokenize\expandafter{\csE}\par
-\StrExpand[3]{\csD}{\csE} depth 3 :
+\StrExpand[3]{\csD}{\csE} level 3 :
\detokenize\expandafter{\csE}\par
-\StrExpand[4]{\csD}{\csE} depth 4 :
-\detokenize\expandafter{\csE}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \def\csA{1 2}
- \def\csB{a \csA}
- \def\csC{\csB\space}
- \def\csD{x{\csA y}\csB{\csC z}}
- Expansion of \string\csD\ at\par
- \StrExpand[0]{\csD}{\csE} depth 0 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[1]{\csD}{\csE} depth 1 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[2]{\csD}{\csE} depth 2 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[3]{\csD}{\csE} depth 3 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[4]{\csD}{\csE} depth 4 :
- \detokenize\expandafter{\csE}
-\end{minipage}%
+\StrExpand[4]{\csD}{\csE} level 4 :
+\detokenize\expandafter{\csE}+
\medskip
-The macro expands each token consecutively, and does not see what follows: tokens whose expansion depends on other tokens cannot be expanded with this macro. For instance, though "\hbox{\verbinline|\iftrue A\else B\fi|}" has a natural expansion ("A"), it cannot be put in the argument of \verbinline|\StrExpand| and:\par\nobreak\smallskip
-\hfil\verbinline|\StrExpand{\iftrue A\else B\fi}\resultat|\hfil{}\par\nobreak\smallskip
-provokes an error because the first token "\verbinline|\iftrue|" is expanded \emph{alone} without seeing its \verbinline-\fi- which makes \TeX{} angry.
+The macro expands each token consecutively, and does not see what follows: tokens whose expansion depends on other tokens cannot be expanded with this macro. For instance, though "\hbox{\verb|\iftrue A\else B\fi|}" has a natural expansion ("A"), it cannot be put in the argument of \verb|\StrExpand| and:\par\nobreak\smallskip
+\hfil\verb|\StrExpand{\iftrue A\else B\fi}\result|\hfil{}\par\nobreak\smallskip
+provokes an error because the first token "\verb|\iftrue|" is expanded \emph{alone} without seeing its \verb-\fi- which makes \TeX{} angry.
+
+Expansion inside groups is \emph{independant} of the exploration mode: this macro has its own command to expand or not what is inside the groups. By default, tokens inside groups are expanded, but this can be changed with the macro \verb-\noexpandingroups-. The default behaviour can be recoverd with \verb-\expandingroups-.\bigskip
-Expansion inside groups is \emph{independant} of the exploration mode: this macro has its own command to expand or not what is inside the groups. By default, tokens inside groups are expanded, but this can be changed with the macro \verbinline-\noexpandingroups-. The default behaviour can be recoverd with \verbinline-\expandingroups-.\bigskip
+The \verb-\scancs- macro returns the detokenized result:\par\nobreak\medskip
+\verb|\scancs|\arguC{number}\ARGU{name}\ARGU{string}\par\nobreak\smallskip
-The \verbinline-\scancs- macro returns the detokenized result:\par\nobreak\medskip
-\verbinline|\scancs|\arguC{number}\ARGU{name}\ARGU{string}\par\nobreak\smallskip
The \argu{number} is 1 by default and represents the number of expansions.\smallskip
-\verbinline-\scancs- has been kept for compatibility with older versions of \Xstring. This macro now unnecessry, simply takes the result of \verbinline|\StrExpand| and \verbinline|\detokenize| it.
+\verb-\scancs- has been kept for compatibility with older versions of \Xstring. This macro now unnecessry, simply takes the result of \verb|\StrExpand| and \verb|\detokenize| it.
\subsection{Inside the definition of a macro}
-Some difficulties arise inside the definition of a macro, i.e. between braces following a \verbinline|\def\macro| or a\\\verbinline|\newcommand\macro|.\medskip
+Some difficulties arise inside the definition of a macro, i.e. between braces following a \verb|\def\macro| or a\\\verb|\newcommand\macro|.\medskip
-It is forbidden to use the command \verbinline|\verb| inside the definition of a macro. For the same reasons:\par\medskip
+It is forbidden to use the command \verb|\verb| inside the definition of a macro. For the same reasons:\par\medskip
\hfill\textbf{Do not use \texttt{\textbackslash verbtocs} inside the definition of a macro}.\hfill{}\medskip
But then, how to manipulate special characters and "verbatimize" inside the définition of macros ?\bigskip
-The \verbinline|\detokenize| primitive of $\varepsilon$-\TeX can be used but it has limitations:
+The \verb|\detokenize| primitive of $\varepsilon$-\TeX can be used but it has limitations:
\begin{itemize}
\item braces must be balanced;
\item consecutive spaces make a single space;
@@ -1744,12 +1150,10 @@ The \verbinline|\detokenize| primitive of $\varepsilon$-\TeX can be used but it
\end{itemize}
\medskip
-It is better to use \verbinline|\scancs| and define \emph{outside the definition of the macros} control sequences containing special characters with \verbinline|\verbtocs|. It is also possible to use \verbinline|\tokenize| to transform the final result (which is generaly \texte{10,11,12}) into control sequences. See example using these macros at the end of this manual, page~\pageref{exemples}.\medskip
+It is better to use \verb|\scancs| and define \emph{outside the definition of the macros} control sequences containing special characters with \verb|\verbtocs|. It is also possible to use \verb|\tokenize| to transform the final result (which is generaly \texte{10,11,12}) into control sequences.\medskip
In the following teaching example\footnote{It is possible to make much more simple using \texttt{\textbackslash detokenize}. The macro becomes:\par\texttt{\textbackslash newcommand\textbackslash bracearg[1]\{\textbackslash detokenize\{\{\#1\}\}\}}}, the macro \verb|\bracearg| adds braces to its argument. To make this possible, 2 control sequences \verb|\Ob| and \verb|\Cb| containing "\verb|{|" and "\verb|}|" are defined outside the definition of \verb|\bracearg|, and expanded inside it:\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\verbtocs{\Ob}|{|
+\showcode+\verbtocs{\Ob}|{|
\verbtocs{\Cb}|}|
\newcommand\bracearg[1]{%
\def\text{#1}%
@@ -1757,295 +1161,30 @@ In the following teaching example\footnote{It is possible to make much more simp
\result}
\bracearg{xstring}\par
-\bracearg{\a}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\Ob}|{|
- \verbtocs{\Cb}|}|
- \newcommand\bracearg[1]{%
- \def\text{#1}%
- \scancs{\result}{\Ob\text\Cb}%
- \result}
-
- \bracearg{xstring}\par
- \bracearg{\a}
-\end{minipage}%
+\bracearg{\a}+
\subsection{The macro \ttfamily\textbackslash StrRemoveBraces}
Advanced users may need to remove the braces of an argument.
-The macro \verbinline|\StrRemoveBraces| does this. Its syntax is:\smallskip
+The macro \verb|\StrRemoveBraces| does this. Its syntax is:\smallskip
-\verbinline|\StrRemoveBraces|\ARGU{string}\arguC{name}
+\verb|\StrRemoveBraces|\ARGU{string}\arguC{name}
\smallskip
-This macro is sensitive to exploration mode and will remove \emph{all} the braces with \verbinline|\exploregroups| while it will remove braces of lower level with \verbinline|\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
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexploregroups
+\showcode+\noexploregroups
\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
\meaning\mycs
\exploregroups
\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
-\meaning\mycs
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexploregroups
- \StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
- \meaning\mycs
-
- \exploregroups
- \StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
- \meaning\mycs
-\end{minipage}%
-
-\subsection{Examples}
-\label{exemples}
-Here are some very simple examples involving the macros of this package in programming purposes.
-
-\subsubsection{Example 1}
-We want to substitute the 2 first \verbinline|\textit| by \verbinline|\textbf| in the control sequence \verb|\myCS| which contains \par\smallskip
-\hfill\verbinline|\textit{A}\textit{B}\textit{C}|\hfill{}
-\medskip
-
-We expect: \textbf{A}\textbf{B}\textit{C}\medskip
-
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\expandarg
-\def\myCS{\textit{A}\textit{B}\textit{C}}
-\def\pattern{\textit}
-\def\replace{\textbf}
-\StrSubstitute[2]{\myCS}{\pattern}{\replace}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \expandarg
- \def\myCS{\textit{A}\textit{B}\textit{C}}
- \def\pattern{\textit}
- \def\replace{\textbf}
- \StrSubstitute[2]{\myCS}{\pattern}{\replace}
-\end{minipage}%
-\medskip
-
-It is possible to avoid to define \verb|\pattern| and \verb|\replace|: a "snare" can be used. It can be a control sequence which expansion is empty, like the famous \verbinline|\empty|. The code would have been:\par\nobreak\smallskip
-\hfil\verbinline|\StrSubstitute[2]{\myCS}{\empty\textit}{\empty\textbf}|\hfil{}\medskip
-
-With this code, in both arguments, the first token \verbinline|\empty| is expanded to "nothing" and the following significant tokens \verbinline|\textit| and \verbinline|textbf| are left unchanged.\smallskip
-
-By this way, \verbinline|\empty| is a way to "hack" \verbinline|\expandarg|: it allows to avoid the expansion of all the other tokens. The control sequence \verbinline|\noexpand| can be used instead of \verbinline|\empty| for the same result.
-
-\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:\par\nobreak
-\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:\par\nobreak\medskip
-
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\newcommand\StringDel[4]{%
- \begingroup
- \expandarg% locally in this group
- \StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
- \StrGobbleLeft{\empty#1}{\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{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \newcommand\StringDel[4]{%
- \begingroup
- \expandarg% locally in this group
- \StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
- \StrGobbleLeft{\empty#1}{\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 \verbinline|\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:\par\nobreak\smallskip
-\hfil\verbinline|\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 \verbinline|\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 \verbinline|\frac| :\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
-\newcommand\tofrac[1]{%
- \StrBefore{#1}{/}[\num]%
- \StrBehind{#1}{/}[\den]%
- $\frac{\num}{\den}$%
-}
-\tofrac{15/9}
-\tofrac{u_{n+1}/u_n}
-\tofrac{a^m/a^n}
-\tofrac{x+\sqrt{x}/\sqrt{x^2+x+1}}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \newcommand\tofrac[1]{%
- \StrBefore{#1}{/}[\num]%
- \StrBehind{#1}{/}[\den]%
- $\frac{\num}{\den}$%
- }
- \tofrac{15/9}
- \tofrac{u_{n+1}/u_n}
- \tofrac{a^m/a^n}
- \tofrac{x+\sqrt{x}/\sqrt{x^2+x+1}}
-\end{minipage}%
-
-\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}[c]{0.65\linewidth}
-\begin{lstlisting}
-\newcommand\boldafter[2]{%
- \noexpandarg
- \StrBehind[1]{#1 }{ #2 }[\word]%
- \expandarg
- \StrBefore{\word}{ }[\word]%
- \StrSubstitute[1]{#1}{\word}{\textbf{\word}}%
-}
-
-\boldafter{The xstring package is new}{xstring}
-
-\boldafter{The xstring package is new}{ring}
-
-\boldafter{The xstring package is new}{is}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \newcommand\boldafter[2]{%
- \noexpandarg
- \StrBehind[1]{#1 }{ #2 }[\word]%
- \expandarg
- \StrBefore{\word}{ }[\word]%
- \StrSubstitute[1]{#1}{\word}{\textbf{\word}}%
- }
-
- \boldafter{The xstring package is new}{xstring}
-
- \boldafter{The xstring package is new}{ring}
-
- \boldafter{The xstring package is new}{is}
-\end{minipage}%
-\fullexpandarg
-
-\subsubsection{Example 5}
-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 \verbinline|\scancs| is necessary: after the detokenization of the argument, it becomes possible to search the char \verb|\| (catcode 12). At line 5, a retokenization is done by \verbinline|\tokenize| and \verb|\before| and \verb|\after| are swapped at this moment.\medskip
-
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\verbtocs{\antislash}|\|
-\newcommand\swaptwofirst[1]{%
- \begingroup
- \fullexpandarg
- \scancs[0]\mystring{#1}%
- \StrBefore[3]{\mystring}{\antislash}[\firsttwo]%
- \StrBehind{\mystring}{\firsttwo}[\others]
- \StrBefore[2]{\firsttwo}{\antislash}[\before]
- \StrBehind{\firsttwo}{\before}[\after]%
- \tokenize\myCS{\after\before\others}%
- \myCS
- \endgroup
-}
-
-\swaptwofirst{\underline{A}\textbf{B}\textit{C}}
-
-\swaptwofirst{\Large\underline{A}\textbf{B}123}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\antislash}|\|
- \newcommand\swaptwofirst[1]{%
- \begingroup
- \fullexpandarg
- \scancs[0]\mystring{#1}%
- \StrBefore[3]{\mystring}{\antislash}[\firsttwo]%
- \StrBehind{\mystring}{\firsttwo}[\others]
- \StrBefore[2]{\firsttwo}{\antislash}[\before]
- \StrBehind{\firsttwo}{\before}[\after]%
- \tokenize\myCS{\after\before\others}%
- \myCS
- \endgroup
- }
-
- \swaptwofirst{\underline{A}\textbf{B}\textit{C}}
-
- \swaptwofirst{\Large\underline{A}\textbf{B}123}
-\end{minipage}%
-
-
-\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 \verbinline|\StrBetween| and \verbinline|\numexpr|:\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\newcommand\findword[3][ ]{%
- \StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}%
-}
-\noexpandarg
-|\findword{a bc d\textbf{e f} gh}{3}|
-
-|\findword[\nil]{1 \nil 2 3 \nil4\nil5}{2}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \newcommand\findword[3][ ]{%
- \StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}%
- }
- \noexpandarg
- |\findword{a bc d\textbf{e f} gh}{3}|
-
- |\findword[\nil]{1 \nil 2 3 \nil4\nil5}{2}|
-\end{minipage}%
-
-\bigskip\bigskip
+\meaning\mycs+
\begin{center}
$\star$\par
$\star$\quad$\star$
\end{center}
-\par\nobreak\bigskip\bigskip
+
That's all, I hope you will find this package useful!\par\nobreak
Please, send me an \href{mailto:unbonpetit@netc.fr}{email} if you find a bug or if you have any idea of improvement\ldots\par\nobreak\medskip
Christian Tellechea
diff --git a/macros/generic/xstring/xstring-fr.pdf b/macros/generic/xstring/xstring-fr.pdf
index 703674d7c6..6b49742708 100644
--- a/macros/generic/xstring/xstring-fr.pdf
+++ b/macros/generic/xstring/xstring-fr.pdf
Binary files differ
diff --git a/macros/generic/xstring/xstring-fr.tex b/macros/generic/xstring/xstring-fr.tex
index 0949306ec0..2210d76235 100644
--- a/macros/generic/xstring/xstring-fr.tex
+++ b/macros/generic/xstring/xstring-fr.tex
@@ -1,3 +1,4 @@
+% !TeX TS-program = lualatex
\documentclass[a4paper,10pt,french]{article}
\usepackage{fontspec}
\usepackage[bookmarks=true,bookmarksopen=true,colorlinks=true,hyperfootnotes=false,filecolor=black,linkcolor=blue,urlcolor=blue,pdfauthor={Christian Tellechea},pdftitle={xstring},pdfsubject={package pour la manipulation de chaines de tokens},pdfkeywords={xstring,latex,tex,string,chaine},pdfcreator={LaTeX}]{hyperref}
@@ -5,58 +6,97 @@
\usepackage{libertine}
\usepackage[scale=0.85]{noto-mono}
\usepackage[bottom]{footmisc}
-\usepackage{amsmath,amssymb,amsfonts,color,eurosym,xspace,xstring,babel,listings}
+\usepackage{amsmath,amssymb,amsfonts,xcolor,eurosym,xspace,xstring,babel}
\makeatletter
-\definecolor{@xs@bckgcolor}{rgb}{0.9,1,1}
-\definecolor{@xs@keywordsxstring}{rgb}{0,0,0.9}
-\definecolor{@xs@keywordslatex}{rgb}{1,0,0}
-\definecolor{@xs@arguments}{rgb}{0,0,0}
-\definecolor{@xs@comments}{rgb}{0.5,0.5,0.5}
+\newcommand\make@car@active[1]{%
+ \catcode`#1\active
+ \begingroup
+ \lccode`\~`#1\relax
+ \lowercase{\endgroup\def~}%
+}
+
+\newcount\code@line
+\newbox\box@code
+\newbox\box@exec
+\newbox\box@bkgd
+
+\newcommand*\showcode{%
+ \begingroup
+ \parskip\z@
+ \parindent\z@
+ \code@line\z@
+ \@makeother\;\@makeother\!\@makeother\?\@makeother\:
+ \medbreak
+ \noindent
+ \begingroup
+ \let\do\@makeother\dospecials
+ \make@car@active\ { }%
+ \make@car@active\^^M{\par\leavevmode}%
+ \make@car@active\^^I{\space\space\space\space}%
+ \make@car@active\,{\leavevmode\kern\z@\string,}%
+ \make@car@active\-{\leavevmode\kern\z@\string-}%
+ \showcode@a
+}
+
+\newcommand\showcode@a[2][65]{%
+ \def\@tempa##1#2{%
+ \xdef\the@code{##1}%
+ \endgroup
+ \showcode@b{#1}{##1}}%
+ \@tempa}
+
+\newcommand\showcode@b[2]{%
+ \vskip0.5ex
+ \fboxsep5pt
+ \setbox\box@code=\hbox{%
+ $\vcenter{
+ \hsize\dimexpr0.#1\linewidth-\fboxsep-\fboxrule\relax
+ \parskip0pt
+ \ttfamily
+ \small
+ \everypar{\llap{\global\advance\code@line\@ne\tiny\number\code@line\kern\dimexpr\fboxsep+3pt }}%
+ \the@code\par
+ }$%
+ }%
+ \setbox\box@exec=\hbox{%
+ $\vcenter{
+ \hsize\dimexpr\linewidth-0.#1\linewidth-\fboxsep-\fboxrule\relax
+ \small
+ \newlinechar`\^^M\everyeof{\noexpand}%
+ \scantokens{#2}%
+ }$%
+ }%
+ \fbox{%
+ \begingroup
+ \color{black!15}%
+ \setbox\box@bkgd=\hbox{% fond code
+ \vrule width\wd\box@code
+ height\dimexpr\max@dim{\ht\box@code}{\ht\box@exec}+\fboxsep\relax
+ depth \dimexpr\max@dim{\dp\box@code}{\dp\box@exec}+\fboxsep\relax
+ }%
+ \wd\box@bkgd=0pt \ht\box@bkgd=0pt \dp\box@bkgd=0pt
+ \kern-\fboxsep
+ \box\box@bkgd
+ \kern\fboxsep
+ \endgroup
+ \setbox\box@bkgd=\hbox{% réglure verticale
+ \vrule width.5pt
+ height\dimexpr\max@dim{\ht\box@code}{\ht\box@exec}+\fboxsep\relax
+ depth \dimexpr\max@dim{\dp\box@code}{\dp\box@exec}+\fboxsep\relax
+ }%
+ \box\box@code
+ \wd\box@bkgd=0pt \ht\box@bkgd=0pt \dp\box@bkgd=0pt
+ \kern-\fboxsep
+ \box\box@bkgd
+ \kern\fboxsep
+ \box\box@exec
+ }%
+ \medbreak
+ \endgroup
+}
+\def\max@dim#1#2{\ifdim#1>#2 #1\else#2\fi}
+
\definecolor{violet}{rgb}{0.66,0,0.66}
-\lstset{%
- language=[AlLaTeX]TeX,%
- morekeywords={numexpr,detokenize},%
- float=hbp,%
- basicstyle=\small\ttfamily,%
- identifierstyle=\color{@xs@arguments},%
- keywordstyle=\color{@xs@keywordslatex},%
- commentstyle=\itshape\color{@xs@comments},%
- columns=fixed,%
- tabsize=4,%
- frame=single,%
- extendedchars=true,%
- showspaces=false,%
- showstringspaces=false,%
- numbers=left,%
- numberstyle=\tiny\ttfamily,%
- breaklines=true,%
- breakindent=3em,%
- backgroundcolor=\color{@xs@bckgcolor},%
- breakautoindent=true,%
- captionpos=t,%
- xleftmargin=1em,%
- xrightmargin=1em,%
- lineskip=0pt,%
- numbersep=1em,%
- classoffset=1,%
- morekeywords={% les macros et commandes de xstring
- IfSubStr,IfSubStrBefore,IfSubStrBehind,%
- IfBeginWith,IfEndWith,%
- IfInteger,IfDecimal,integerpart,decimalpart,%
- IfStrEq,IfEq,IfStrEqCase,IfEqCase,%
- StrBefore,StrBehind,StrCut,StrBetween,%
- StrSubstitute,StrDel,%
- StrGobbleLeft,StrGobbleRight,StrRight,StrLeft,StrMid,StrChar,%
- StrSplit,%
- StrLen,StrCount,StrPosition,StrCompare,%
- StrFindGroup,groupID,verbtocs,tokenize,scancs,StrExpand,StrRemoveBraces,%
- exploregroups,noexploregroups,saveexploremode,restoreexploremode,%
- comparenormal,comparestrict,savecomparemode,restorecomparemode,%
- expandarg,noexpandarg,normalexpandarg,fullexpandarg,saveexpandmode,restoreexpandmode,%
- expandingroups,noexpandingroups,%
- setverbdelim},%
- keywordstyle=\color{@xs@keywordsxstring},%
- classoffset=0}
\makeatother
\newcommand\guill[1]{\og{}#1\fg{}}
@@ -79,9 +119,8 @@
\newcommand\US{unité syntaxique\xspace}
\newcommand\USs{unités syntaxiques\xspace}
\newcommand\Xstring{\textsf{xstring}\xspace}
-\newcommand\styleexemple{\small\baselineskip1.03\baselineskip\vskip\baselineskip\relax}
+\newcommand\styleexemple{\small\vskip.4\baselineskip\relax}
\newcommand\styleexercice{\footnotesize}
-\newcommand\verbinline{\lstinline[basicstyle=\normalsize\ttfamily]}
\newcommand\colorise{\color{violet}}
\def\xstringfrenchdateaux#1/#2/#3\nil{\number#3\relax\ifnum#3=1 \noexpand\ier\fi\space \ifcase #2 \or janvier\or f\'evrier\or mars\or avril\or mai\or juin\or juillet\or aout\or septembre\or octobre\or novembre\or d\'ecembre\fi\space#1}
\edef\xstringfrenchdate{\expandafter\xstringfrenchdateaux\xstringdate\nil}
@@ -109,37 +148,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 de tokens (ou lexèmes en français). 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 tokens, c'est-à-dire du code \TeX{}. Parmis les fonctionnalités, les principales sont :\smallskip
-
- \parindent1.5em
- \begin{itemize}
- \item[$\triangleright$] des tests :
- \begin{itemize}
- \item une chaîne en contient elle une autre au moins $n$ fois ?
- \item une chaîne commence t-elle ou finit-elle par une autre ? etc.
- \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 recherches de chaînes :
- \begin{itemize}
- \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 :
- \begin{itemize}
- \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 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 tokens spéciaux normalement interdits dans les chaînes (\verb|#| et \verb|%|), ainsi que d'éventuelles différences entre catcodes de tokens, ce qui devrait permettre de couvrir tous les besoins en matière de programmation.
+ Cette extension fournit un ensemble de macros manipulant des chaînes de tokens. Les macros, non développables, peuvent être utilisées de façon basique dans le traitement des chaînes de caractères mais peuvent également être utiles en programmation \TeX{} pour la manipulation des tokens, c'est-à-dire du code \TeX{}.
\end{minipage}
\end{center}
\hrulefill\vfill{}
@@ -149,47 +158,36 @@
%
\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 tokens, un peu comme en disposent des langages dit \guill{évolués}. On y trouve les opérations habituelles sur les chaînes, comme par exemple : test si une chaîne en contient une autre, commence ou finit par une autre, test si une chaîne est un nombre entier ou décimal, extractions de sous-chaînes, calculs de position d'une sous-chaîne, calculs du nombre d'occurrences, etc.\medskip
+Cette extension\footnote{L'extension ne nécessite pas \LaTeX{} et peut être compilée sous Plain $\varepsilon$-\TeX{}.} regroupe des macros et des tests non développables opérant sur des chaînes de tokens, un peu comme en disposent des langages dit \guill{évolués}. On y trouve les opérations habituelles sur les chaînes, comme par exemple : test si une chaîne en contient une autre, commence ou finit par une autre, test si une chaîne est un nombre entier ou décimal, extractions de sous-chaînes, calculs de position d'une sous-chaîne, calculs du nombre d'occurrences, etc.\medskip
-On appelle \guill{chaîne de tokens} une suite de tokens quelconques, sachant qu'aucune supposition n'a été faite quant à leur nature, mis à part que dans les chaînes de tokens, les accolades doivent être équilibrées et que les tokens de catcode 6 et 14 (habituellement \verb|%| et \verb|#|) n'y sont pas admis. Tous les autres tokens, y compris \verbinline|\par|, sont \emph{à priori} permis dans n'importe quel ordre, quel que soit le code qu'ils représentent.\medskip
+On appelle \guill{chaîne de tokens} une suite de tokens quelconques, sachant qu'aucune supposition n'a été faite quant à leur nature, mis à part que dans les chaînes de tokens, les accolades doivent être équilibrées et que les tokens de catcode 6 et 14 (habituellement \verb|%| et \verb|#|) n'y sont pas admis. Tous les autres tokens, y compris \verb|\par|, sont \emph{à priori} permis dans n'importe quel ordre, quel que soit le code qu'ils représentent.\medskip
-Les arguments contenant des chaînes de tokens sont lus par \Xstring \emph{\US par \US\footnote{Sauf cas particulier, une \US est un caractère lu dans le code à 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 tokens \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 tokens dont les catcodes sont moins inoffensifs. Voir le chapitre sur le mode de lecture et de développement des arguments (page~\pageref{developpementarguments}), la commande \verbinline|\verbtocs| (page~\pageref{verbtocs}), la commande \verbinline|\scancs| (page~\pageref{scancs}).\medskip
+Les arguments contenant des chaînes de tokens sont lus par \Xstring \emph{\US par \US\footnote{Sauf cas particulier, une \US est un caractère lu dans le code à 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 tokens \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 tokens dont les catcodes sont moins inoffensifs. Voir le chapitre sur le mode de lecture et de développement des arguments (page~\pageref{developpementarguments}), la commande \verb|\verbtocs| (page~\pageref{verbtocs}), la commande \verb|\scancs| (page~\pageref{scancs}).\medskip
Certes d'autres packages manipulant les chaînes de caractères existent (par exemple \href{http://mirror.ctan.org/tex-archive/macros/latex/contrib/substr/}{\nolinkurl{substr}} et \href{http://mirror.ctan.org/tex-archive/macros/latex/contrib/stringstrings/}{\nolinkurl{stringstrings}}), mais outre des différences notables quant aux fonctionnalités, ils ne prennent pas en charge les occurrences des sous-chaînes et me semblent soit trop limités, soit trop difficiles à utiliser pour la programmation.\medskip
Comme les macros manipulent des chaînes de tokens, il peut arriver aux utilisateurs avancés de rencontrer des problèmes de \guill{catcodes\footnote{Codes de catégories, en français.}} conduisant à des comportements inattendus. Ces effets indésirables peuvent être contrôlés. Consulter en particulier le chapitre sur les catcodes des arguments page~\pageref{macrosetoilees}.
-\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. 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œur, j'ai fini par choisir des noms de macros à consonances anglo-saxonnes.\medskip
-
-Ensuite, et cela a été ma principale motivation puisque j'ai découvert \LaTeX{} récemment\footnote{En novembre 2007, je suis donc un \og noob\fg{} pour longtemps encore !}, l'écriture de \Xstring qui est mon premier package m'a surtout permis de beaucoup progresser en programmation pure, et aborder des méthodes propres à la programmation sous \TeX.
-
\section{Les macros}
Pour bien comprendre les actions de chaque macro, envisageons tout d'abord le fonctionnement et la présentation des macros dans leur mode de fonctionnement le plus simple. Pas de problème de catcode ici, ni de tokens spéciaux et encore moins de séquence de contrôle dans les arguments : les arguments contiendront des caractères alphanumériques.\medskip
-Dans ce chapitre, la totalité des macros est présentée selon ce plan :\par\nobreak\smallskip
-\parindent3em
+Dans ce chapitre, la totalité des macros est présentée selon ce plan :\par\nobreak\smallskip\parindent3em
\begin{itemize}
\item la syntaxe complète\footnote{L'étoile optionnelle après le nom de la macro, et l'argument optionnel entre crochet venant en dernier seront expliqués plus tard. Voir page~\pageref{macrosetoilees} pour les macros étoilées et page~\pageref{argumentoptionnel} pour l'argument optionnel en dernière position.} ainsi que la valeur d'éventuels arguments optionnels;
\item une brève description du fonctionnement;
\item le fonctionnement sous certaines conditions particulières. Pour chaque conditions envisagée, le fonctionnement décrit est prioritaire sur celui (ceux) se trouvant au dessous de lui;
\item enfin, quelques exemples sont donnés. J'ai essayé de les trouver les plus facilement compréhensibles et les plus représentatifs des situations rencontrées dans une utilisation normale\footnote{Pour une collection plus importante d'exemples, on peut aussi consulter le fichier de test.}. Si un doute est possible quant à 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|.\smallskip
+\end{itemize}\parindent0pt\smallskip
-Dans le reste du texte, les macros de \Xstring sont affichées en {\makeatletter\color{@xs@keywordsxstring}bleu}.
+\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}
-\verbinline|\IfSubStr|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
+\verb|\IfSubStr|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
\smallskip
L'argument optionnel \argu{nombre} vaut 1 par défaut.\par\nobreak\smallskip
+
Teste si \argu{chaine} contient au moins \argu{nombre} fois \argu{chaineA} et exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip
\begin{Conditions}
@@ -197,33 +195,20 @@ Teste si \argu{chaine} contient au moins \argu{nombre} fois \argu{chaineA} et ex
\item Si \argu{chaine} ou \argu{chaineA} est vide, exécute \argu{faux}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfSubStr{xstring}{tri}{vrai}{faux}
-\IfSubStr{xstring}{a}{vrai}{faux}
-\IfSubStr{a bc def }{c d}{vrai}{faux}
-\IfSubStr{a bc def }{cd}{vrai}{faux}
-\IfSubStr[2]{1a2a3a}{a}{vrai}{faux}
-\IfSubStr[3]{1a2a3a}{a}{vrai}{faux}
-\IfSubStr[4]{1a2a3a}{a}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfSubStr{xstring}{tri}{vrai}{faux}\par
- \IfSubStr{xstring}{a}{vrai}{faux}\par
- \IfSubStr{a bc def }{c d}{vrai}{faux}\par
- \IfSubStr{a bc def }{cd}{vrai}{faux}\par
- \IfSubStr[2]{1a2a3a}{a}{vrai}{faux}\par
- \IfSubStr[3]{1a2a3a}{a}{vrai}{faux}\par
- \IfSubStr[4]{1a2a3a}{a}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfSubStr{xstring}{tri}{vrai}{faux}\par
+\IfSubStr{xstring}{a}{vrai}{faux}\par
+\IfSubStr{a bc def }{c d}{vrai}{faux}\par
+\IfSubStr{a bc def }{cd}{vrai}{faux}\par
+\IfSubStr[2]{1a2a3a}{a}{vrai}{faux}\par
+\IfSubStr[3]{1a2a3a}{a}{vrai}{faux}\par
+\IfSubStr[4]{1a2a3a}{a}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfSubStrBefore}
-\verbinline|\IfSubStrBefore|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
+\verb|\IfSubStrBefore|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
\smallskip
Les arguments optionnels \argu{nombre1} et \argu{nombre2} valent 1 par défaut.\par\nobreak\smallskip
+
Dans \argu{chaine}, la macro teste si l'occurrence \no\argu{nombre1} de \argu{chaineA} se trouve à gauche de l'occurrence \no\argu{nombre2} de \argu{chaineB}. Exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip
\begin{Conditions}
@@ -232,37 +217,22 @@ Dans \argu{chaine}, la macro teste si l'occurrence \no\argu{nombre1} de \argu{ch
\item Si l'un au moins des deux arguments optionnels est négatif ou nul, exécute \argu{faux}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfSubStrBefore{xstring}{st}{in}{vrai}{faux}
-\IfSubStrBefore{xstring}{ri}{s}{vrai}{faux}
-\IfSubStrBefore{LaTeX}{LaT}{TeX}{vrai}{faux}
-\IfSubStrBefore{a bc def }{ b}{ef}{vrai}{faux}
-\IfSubStrBefore{a bc def }{ab}{ef}{vrai}{faux}
-\IfSubStrBefore[2,1]{b1b2b3}{b}{2}{vrai}{faux}
-\IfSubStrBefore[3,1]{b1b2b3}{b}{2}{vrai}{faux}
-\IfSubStrBefore[2,2]{baobab}{a}{b}{vrai}{faux}
-\IfSubStrBefore[2,3]{baobab}{a}{b}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfSubStrBefore{xstring}{st}{in}{vrai}{faux}\par
- \IfSubStrBefore{xstring}{ri}{s}{vrai}{faux}\par
- \IfSubStrBefore{LaTeX}{LaT}{TeX}{vrai}{faux}\par
- \IfSubStrBefore{a bc def }{ b}{ef}{vrai}{faux}\par
- \IfSubStrBefore{a bc def }{ab}{ef}{vrai}{faux}\par
- \IfSubStrBefore[2,1]{b1b2b3}{b}{2}{vrai}{faux}\par
- \IfSubStrBefore[3,1]{b1b2b3}{b}{2}{vrai}{faux}\par
- \IfSubStrBefore[2,2]{baobab}{a}{b}{vrai}{faux}\par
- \IfSubStrBefore[2,3]{baobab}{a}{b}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfSubStrBefore{xstring}{st}{in}{vrai}{faux}\par
+\IfSubStrBefore{xstring}{ri}{s}{vrai}{faux}\par
+\IfSubStrBefore{LaTeX}{LaT}{TeX}{vrai}{faux}\par
+\IfSubStrBefore{a bc def }{ b}{ef}{vrai}{faux}\par
+\IfSubStrBefore{a bc def }{ab}{ef}{vrai}{faux}\par
+\IfSubStrBefore[2,1]{b1b2b3}{b}{2}{vrai}{faux}\par
+\IfSubStrBefore[3,1]{b1b2b3}{b}{2}{vrai}{faux}\par
+\IfSubStrBefore[2,2]{baobab}{a}{b}{vrai}{faux}\par
+\IfSubStrBefore[2,3]{baobab}{a}{b}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfSubStrBehind}
-\verbinline|\IfSubStrBehind|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
+\verb|\IfSubStrBehind|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
\smallskip
Les arguments optionnels \argu{nombre1} et \argu{nombre2} valent 1 par défaut.\par\nobreak\smallskip
+
Dans \argu{chaine}, la macro teste si l'occurrence \no\argu{nombre1} de \argu{chaineA} se trouve après l'occurrence \\\no\argu{nombre2} de \argu{chaineB}. Exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip
\begin{Conditions}
@@ -271,34 +241,18 @@ Dans \argu{chaine}, la macro teste si l'occurrence \no\argu{nombre1} de \argu{ch
\item Si l'un au moins des deux arguments optionnels est négatif ou nul, exécute \argu{faux}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfSubStrBehind{xstring}{ri}{xs}{vrai}{faux}
-\IfSubStrBehind{xstring}{s}{i}{vrai}{faux}
-\IfSubStrBehind{LaTeX}{TeX}{LaT}{vrai}{faux}
-\IfSubStrBehind{a bc def }{ d}{a}{vrai}{faux}
-\IfSubStrBehind{a bc def }{cd}{a b}{vrai}{faux}
-\IfSubStrBehind[2,1]{b1b2b3}{b}{2}{vrai}{faux}
-\IfSubStrBehind[3,1]{b1b2b3}{b}{2}{vrai}{faux}
-\IfSubStrBehind[2,2]{baobab}{b}{a}{vrai}{faux}
-\IfSubStrBehind[2,3]{baobab}{b}{a}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfSubStrBehind{xstring}{ri}{xs}{vrai}{faux}\par
- \IfSubStrBehind{xstring}{s}{i}{vrai}{faux}\par
- \IfSubStrBehind{LaTeX}{TeX}{LaT}{vrai}{faux}\par
- \IfSubStrBehind{a bc def }{ d}{a}{vrai}{faux}\par
- \IfSubStrBehind{a bc def }{cd}{a b}{vrai}{faux}\par
- \IfSubStrBehind[2,1]{b1b2b3}{b}{2}{vrai}{faux}\par
- \IfSubStrBehind[3,1]{b1b2b3}{b}{2}{vrai}{faux}\par
- \IfSubStrBehind[2,2]{baobab}{b}{a}{vrai}{faux}\par
- \IfSubStrBehind[2,3]{baobab}{b}{a}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfSubStrBehind{xstring}{ri}{xs}{vrai}{faux}\par
+\IfSubStrBehind{xstring}{s}{i}{vrai}{faux}\par
+\IfSubStrBehind{LaTeX}{TeX}{LaT}{vrai}{faux}\par
+\IfSubStrBehind{a bc def }{ d}{a}{vrai}{faux}\par
+\IfSubStrBehind{a bc def }{cd}{a b}{vrai}{faux}\par
+\IfSubStrBehind[2,1]{b1b2b3}{b}{2}{vrai}{faux}\par
+\IfSubStrBehind[3,1]{b1b2b3}{b}{2}{vrai}{faux}\par
+\IfSubStrBehind[2,2]{baobab}{b}{a}{vrai}{faux}\par
+\IfSubStrBehind[2,3]{baobab}{b}{a}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfBeginWith}
-\verbinline|\IfBeginWith|\etoile\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
+\verb|\IfBeginWith|\etoile\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
\smallskip
Teste si \argu{chaine} commence par \argu{chaineA}, et exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip
@@ -307,24 +261,13 @@ Teste si \argu{chaine} commence par \argu{chaineA}, et exécute \argu{vrai} dans
\item Si \argu{chaine} ou \argu{chaineA} est vide, exécute \argu{faux}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfBeginWith{xstring}{xst}{vrai}{faux}
-\IfBeginWith{LaTeX}{a}{vrai}{faux}
-\IfBeginWith{a bc def }{a b}{vrai}{faux}
-\IfBeginWith{a bc def }{ab}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfBeginWith{xstring}{xst}{vrai}{faux}\par
- \IfBeginWith{LaTeX}{a}{vrai}{faux}\par
- \IfBeginWith{a bc def }{a b}{vrai}{faux}\par
- \IfBeginWith{a bc def }{ab}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfBeginWith{xstring}{xst}{vrai}{faux}\par
+\IfBeginWith{LaTeX}{a}{vrai}{faux}\par
+\IfBeginWith{a bc def }{a b}{vrai}{faux}\par
+\IfBeginWith{a bc def }{ab}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfEndWith}
-\verbinline|\IfEndWith|\etoile\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
+\verb|\IfEndWith|\etoile\ARGU{chaine}\ARGU{chaineA}\ARGU{vrai}\ARGU{faux}
\smallskip
Teste si \argu{chaine} se termine par \argu{chaineA}, et exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\medskip
@@ -333,66 +276,39 @@ Teste si \argu{chaine} se termine par \argu{chaineA}, et exécute \argu{vrai} da
\item Si \argu{chaine} ou \argu{chaineA} est vide, exécute \argu{faux}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfEndWith{xstring}{ring}{vrai}{faux}
-\IfEndWith{LaTeX}{a}{vrai}{faux}
-\IfEndWith{a bc def }{ef }{vrai}{faux}
-\IfEndWith{a bc def }{ef}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfEndWith{xstring}{ring}{vrai}{faux}\par
- \IfEndWith{LaTeX}{a}{vrai}{faux}\par
- \IfEndWith{a bc def }{ef }{vrai}{faux}\par
- \IfEndWith{a bc def }{ef}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfEndWith{xstring}{ring}{vrai}{faux}\par
+\IfEndWith{LaTeX}{a}{vrai}{faux}\par
+\IfEndWith{a bc def }{ef }{vrai}{faux}\par
+\IfEndWith{a bc def }{ef}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfInteger}
-\verbinline|\IfInteger|\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
+\verb|\IfInteger|\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
\smallskip
Teste si \argu{nombre} est un nombre entier relatif (c'est-à-dire dont la partie décimale est absente ou constituée d'une suite de 0), et exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\par\nobreak\smallskip
-Si le test est faux pour cause de caractères non autorisés, les séquences de contrôle \verb|\@xs@afterinteger| et \verb|\afterinteger| contiennent chacune la partie illégale de \argu{nombre}.\medskip
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfInteger{13}{vrai}{faux}
-\IfInteger{-219}{vrai}{faux}
-\IfInteger{+9}{vrai}{faux}
-\IfInteger{3.14}{vrai}{faux}
-\IfInteger{8.0}{vrai}{faux}
-\IfInteger{0}{vrai}{faux}
-\IfInteger{49a}{vrai}{faux}
-\IfInteger{+}{vrai}{faux}
-\IfInteger{-}{vrai}{faux}
-\IfInteger{0000}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfInteger{13}{vrai}{faux}\par
- \IfInteger{-219}{vrai}{faux}\par
- \IfInteger{+9}{vrai}{faux}\par
- \IfInteger{3.14}{vrai}{faux}\par
- \IfInteger{8.0}{vrai}{faux}\par
- \IfInteger{0}{vrai}{faux}\par
- \IfInteger{49a}{vrai}{faux}\par
- \IfInteger{+}{vrai}{faux}\par
- \IfInteger{-}{vrai}{faux}\par
- \IfInteger{0000}{vrai}{faux}
-\end{minipage}%
-
-\subsubsection{\ttfamily\textbackslash IfDecimal}
-\label{ifdecimal}
-\verbinline|\IfDecimal|\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
+
+Si le test est faux pour cause de caractères non autorisés, \verb|\afterinteger| contient la partie illégale de \argu{nombre}.\medskip
+
+\showcode|\IfInteger{13}{vrai}{faux}\par
+\IfInteger{-219}{vrai}{faux}\par
+\IfInteger{+9}{vrai}{faux}\par
+\IfInteger{3.14}{vrai}{faux}\par
+\IfInteger{8.0}{vrai}{faux}\par
+\IfInteger{0}{vrai}{faux}\par
+\IfInteger{49a}{vrai}{faux}\par
+\IfInteger{+}{vrai}{faux}\par
+\IfInteger{-}{vrai}{faux}\par
+\IfInteger{0000}{vrai}{faux}|
+
+\subsubsection{\ttfamily\textbackslash IfDecimal}\label{ifdecimal}
+\verb|\IfDecimal|\ARGU{nombre}\ARGU{vrai}\ARGU{faux}
\smallskip
Teste si \argu{nombre} est un nombre décimal, et exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\par\nobreak\smallskip
-Les compteurs \verb|\integerpart| et \verb|\decimalpart| contiennent les parties entières et décimales de \argu{nombre}.
-Si le test est faux pour cause de caractères non autorisés, les séquences de contrôle \verb|\@xs@afterdecimal| et \verb|\afterdecimal| contiennent chacune la partie illégale de \argu{nombre}, alors que si le test est faux parce que la partie décimale après le séparateur décimal est vide, elles contiennent \guill{X}.\medskip
+Les macros \verb|\integerpart| et \verb|\decimalpart| contiennent les parties entières et décimales de \argu{nombre}.
+
+Si le test est faux pour cause de caractères non autorisés, \verb|\afterdecimal| contient la partie illégale de \argu{nombre}, alors que si le test est faux parce que la partie décimale après le séparateur décimal est vide, elle contient \guill{X}.\medskip
\begin{Conditions}
\item Le séparateur décimal peut être un point ou une virgule;
@@ -400,122 +316,65 @@ Si le test est faux pour cause de caractères non autorisés, les séquences de
\item Si le \argu{nombre} se termine par un séparateur décimal, le test est faux (lignes 9 et 10).
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfDecimal{3.14}{vrai}{faux}
-\IfDecimal{3,14}{vrai}{faux}
-\IfDecimal{-0.5}{vrai}{faux}
-\IfDecimal{.7}{vrai}{faux}
-\IfDecimal{,9}{vrai}{faux}
-\IfDecimal{1..2}{vrai}{faux}
-\IfDecimal{+6}{vrai}{faux}
-\IfDecimal{-15}{vrai}{faux}
-\IfDecimal{1.}{vrai}{faux}
-\IfDecimal{2,}{vrai}{faux}
-\IfDecimal{.}{vrai}{faux}
-\IfDecimal{,}{vrai}{faux}
-\IfDecimal{+}{vrai}{faux}
-\IfDecimal{-}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfDecimal{3.14}{vrai}{faux}\par
- \IfDecimal{3,14}{vrai}{faux}\par
- \IfDecimal{-0.5}{vrai}{faux}\par
- \IfDecimal{.7}{vrai}{faux}\par
- \IfDecimal{,9}{vrai}{faux}\par
- \IfDecimal{1..2}{vrai}{faux}\par
- \IfDecimal{+6}{vrai}{faux}\par
- \IfDecimal{-15}{vrai}{faux}\par
- \IfDecimal{1.}{vrai}{faux}\par
- \IfDecimal{2,}{vrai}{faux}\par
- \IfDecimal{.}{vrai}{faux}\par
- \IfDecimal{,}{vrai}{faux}\par
- \IfDecimal{+}{vrai}{faux}\par
- \IfDecimal{-}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfDecimal{3.14}{vrai}{faux}\par
+\IfDecimal{3,14}{vrai}{faux}\par
+\IfDecimal{-0.5}{vrai}{faux}\par
+\IfDecimal{.7}{vrai}{faux}\par
+\IfDecimal{,9}{vrai}{faux}\par
+\IfDecimal{1..2}{vrai}{faux}\par
+\IfDecimal{+6}{vrai}{faux}\par
+\IfDecimal{-15}{vrai}{faux}\par
+\IfDecimal{1.}{vrai}{faux}\par
+\IfDecimal{2,}{vrai}{faux}\par
+\IfDecimal{.}{vrai}{faux}\par
+\IfDecimal{,}{vrai}{faux}\par
+\IfDecimal{+}{vrai}{faux}\par
+\IfDecimal{-}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfStrEq}
-
-\verbinline|\IfStrEq|\etoile\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
+\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 \US dans le même ordre. Exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\smallskip
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfStrEq{a1b2c3}{a1b2c3}{vrai}{faux}
-\IfStrEq{abcdef}{abcd}{vrai}{faux}
-\IfStrEq{abc}{abcdef}{vrai}{faux}
-\IfStrEq{3,14}{3,14}{vrai}{faux}
-\IfStrEq{12.34}{12.340}{vrai}{faux}
-\IfStrEq{abc}{}{vrai}{faux}
-\IfStrEq{}{abc}{vrai}{faux}
-\IfStrEq{}{}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfStrEq{a1b2c3}{a1b2c3}{vrai}{faux}\par
- \IfStrEq{abcdef}{abcd}{vrai}{faux}\par
- \IfStrEq{abc}{abcdef}{vrai}{faux}\par
- \IfStrEq{3,14}{3,14}{vrai}{faux}\par
- \IfStrEq{12.34}{12.340}{vrai}{faux}\par
- \IfStrEq{abc}{}{vrai}{faux}\par
- \IfStrEq{}{abc}{vrai}{faux}\par
- \IfStrEq{}{}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfStrEq{a1b2c3}{a1b2c3}{vrai}{faux}\par
+\IfStrEq{abcdef}{abcd}{vrai}{faux}\par
+\IfStrEq{abc}{abcdef}{vrai}{faux}\par
+\IfStrEq{3,14}{3,14}{vrai}{faux}\par
+\IfStrEq{12.34}{12.340}{vrai}{faux}\par
+\IfStrEq{abc}{}{vrai}{faux}\par
+\IfStrEq{}{abc}{vrai}{faux}\par
+\IfStrEq{}{}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfEq}
-\verbinline|\IfEq|\etoile\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
+\verb|\IfEq|\etoile\ARGU{chaineA}\ARGU{chaineB}\ARGU{vrai}\ARGU{faux}
\smallskip
Teste si les chaînes \argu{chaineA} et \argu{chaineB} sont égales, \emph{sauf} si \argu{chaineA} et \argu{chaineB} contiennent des nombres, auquel cas la macro teste si les nombres sont égaux. Exécute \argu{vrai} dans l'affirmative, et \argu{faux} dans le cas contraire.\smallskip
\begin{Conditions}
- \item La définition de \emph{nombre} est celle évoquée dans la macro \verbinline|\IfDecimal| (voir page~\pageref{ifdecimal}), et donc :
+ \item La définition de \emph{nombre} est celle évoquée dans la macro \verb|\IfDecimal| (voir page~\pageref{ifdecimal}), et donc :
\item Les signes \guill{+} sont facultatifs;
\item Le séparateur décimal peut être indifféremment la virgule ou le point.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfEq{a1b2c3}{a1b2c3}{vrai}{faux}
-\IfEq{abcdef}{ab}{vrai}{faux}
-\IfEq{ab}{abcdef}{vrai}{faux}
-\IfEq{12.34}{12,34}{vrai}{faux}
-\IfEq{+12.34}{12.340}{vrai}{faux}
-\IfEq{10}{+10}{vrai}{faux}
-\IfEq{-10}{10}{vrai}{faux}
-\IfEq{+0,5}{,5}{vrai}{faux}
-\IfEq{1.001}{1.01}{vrai}{faux}
-\IfEq{3*4+2}{14}{vrai}{faux}
-\IfEq{\number\numexpr3*4+2}{14}{vrai}{faux}
-\IfEq{0}{-0.0}{vrai}{faux}
-\IfEq{}{}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfEq{a1b2c3}{a1b2c3}{vrai}{faux}\par
- \IfEq{abcdef}{ab}{vrai}{faux}\par
- \IfEq{ab}{abcdef}{vrai}{faux}\par
- \IfEq{12.34}{12,34}{vrai}{faux}\par
- \IfEq{+12.34}{12.340}{vrai}{faux}\par
- \IfEq{10}{+10}{vrai}{faux}\par
- \IfEq{-10}{10}{vrai}{faux}\par
- \IfEq{+0,5}{,5}{vrai}{faux}\par
- \IfEq{1.001}{1.01}{vrai}{faux}\par
- \IfEq{3*4+2}{14}{vrai}{faux}\par
- \IfEq{\number\numexpr3*4+2}{14}{vrai}{faux}\par
- \IfEq{0}{-0.0}{vrai}{faux}\par
- \IfEq{}{}{vrai}{faux}
-\end{minipage}%
+\showcode|\IfEq{a1b2c3}{a1b2c3}{vrai}{faux}\par
+\IfEq{abcdef}{ab}{vrai}{faux}\par
+\IfEq{ab}{abcdef}{vrai}{faux}\par
+\IfEq{12.34}{12,34}{vrai}{faux}\par
+\IfEq{+12.34}{12.340}{vrai}{faux}\par
+\IfEq{10}{+10}{vrai}{faux}\par
+\IfEq{-10}{10}{vrai}{faux}\par
+\IfEq{+0,5}{,5}{vrai}{faux}\par
+\IfEq{1.001}{1.01}{vrai}{faux}\par
+\IfEq{3*4+2}{14}{vrai}{faux}\par
+\IfEq{\number\numexpr3*4+2}{14}{vrai}{faux}\par
+\IfEq{0}{-0.0}{vrai}{faux}\par
+\IfEq{}{}{vrai}{faux}|
\subsubsection{\ttfamily\textbackslash IfStrEqCase}
\begin{minipage}{\textwidth}
- \verbinline|\IfStrEqCase|\etoile\ARGU{chaine}\verb|{%|\par
+ \verb|\IfStrEqCase|\etoile\ARGU{chaine}\verb|{%|\par
\qquad\qquad\ARGU{chaine1}\ARGU{code1}\verb|%|\par
\qquad\qquad\ARGU{chaine2}\ARGU{code2}\verb|%|\par
\qquad\qquad\verb|etc...|\par
@@ -523,31 +382,18 @@ Teste si les chaînes \argu{chaineA} et \argu{chaineB} sont égales, \emph{sauf}
\end{minipage}
\smallskip
-Teste successivement si \argu{chaine} est égale à \argu{chaine1}, \argu{chaine2}, etc. La comparaison se fait au sens de \verbinline|\IfStrEq| (voir paragraphes précédents). Si un test est positif, le code correspondant est exécuté et la macro se termine. Si tous les tests sont négatifs, le code optionnel \argu{code alternatif} est exécuté s'il est présent.\smallskip
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}
-|\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|
-\IfStrEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]
-\IfStrEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]
-\IfStrEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]
-\IfStrEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
- |\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
- \IfStrEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
- \IfStrEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
- \IfStrEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]\par
- \IfStrEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]
-\end{minipage}%
+Teste successivement si \argu{chaine} est égale à \argu{chaine1}, \argu{chaine2}, etc. La comparaison se fait au sens de \verb|\IfStrEq| (voir paragraphes précédents). Si un test est positif, le code correspondant est exécuté et la macro se termine. Si tous les tests sont négatifs, le code optionnel \argu{code alternatif} est exécuté s'il est présent.\smallskip
+
+\showcode-\IfStrEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
+|\IfStrEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
+\IfStrEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
+\IfStrEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
+\IfStrEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]\par
+\IfStrEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]-
\subsubsection{\ttfamily\textbackslash IfEqCase}
\begin{minipage}{\textwidth}
- \verbinline|\IfEqCase|\etoile\ARGU{chaine}\verb|{%|\par
+ \verb|\IfEqCase|\etoile\ARGU{chaine}\verb|{%|\par
\qquad\qquad\ARGU{chaine1}\ARGU{code1}\verb|%|\par
\qquad\qquad\ARGU{chaine2}\ARGU{code2}\verb|%|\par
\qquad\qquad\verb|etc...|\par
@@ -555,34 +401,22 @@ Teste successivement si \argu{chaine} est égale à \argu{chaine1}, \argu{chaine
\end{minipage}
\smallskip
-Teste successivement si \argu{chaine} est égale à \argu{chaine1}, \argu{chaine2}, etc. La comparaison se fait au sens de \verbinline|\IfEq| (voir paragraphes précédents). Si un test est positif, le code correspondant est exécuté et la macro se termine. Si tous les tests sont négatifs, le code optionnel \argu{code alternatif} est exécuté s'il est présent.\smallskip
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}
-|\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|
-\IfEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]
-\IfEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]
-\IfEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]
-\IfEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
- |\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
- \IfEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
- \IfEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
- \IfEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]\par
- \IfEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]
-\end{minipage}%
+Teste successivement si \argu{chaine} est égale à \argu{chaine1}, \argu{chaine2}, etc. La comparaison se fait au sens de \verb|\IfEq| (voir paragraphes précédents). Si un test est positif, le code correspondant est exécuté et la macro se termine. Si tous les tests sont négatifs, le code optionnel \argu{code alternatif} est exécuté s'il est présent.\smallskip
+
+\showcode-\IfEqCase{b}{{a}{AA}{b}{BB}{c}{CC}}\par
+|\IfEqCase{abc}{{a}{AA}{b}{BB}{c}{CC}}|\par
+\IfEqCase{c}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
+\IfEqCase{d}{{a}{AA}{b}{BB}{c}{CC}}[autre]\par
+\IfEqCase{+3}{{1}{un}{2}{deux}{3}{trois}}[autre]\par
+\IfEqCase{0.5}{{0}{zero}{.5}{demi}{1}{un}}[autre]-
\subsection{Les macros renvoyant une chaîne}
\subsubsection{\ttfamily\textbackslash StrBefore}
-\verbinline|\StrBefore|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
+\verb|\StrBefore|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
\smallskip
L'argument optionnel \argu{nombre} vaut 1 par défaut.\par\nobreak\smallskip
+
Dans \argu{chaine}, renvoie ce qui se trouve avant l'occurrence \no\argu{nombre} de \argu{chaineA}.\medskip
\begin{Conditions}
@@ -591,35 +425,21 @@ Dans \argu{chaine}, renvoie ce qui se trouve avant l'occurrence \no\argu{nombre}
\item Si l'occurrence n'est pas trouvée, une chaîne vide est renvoyée.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrBefore{xstring}{tri}
-\StrBefore{LaTeX}{e}
-|\StrBefore{LaTeX}{p}|
-|\StrBefore{LaTeX}{L}|
-|\StrBefore{a bc def }{def}|
-|\StrBefore{a bc def }{cd}|
-\StrBefore[1]{1b2b3}{b}
-\StrBefore[2]{1b2b3}{b}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrBefore{xstring}{tri}\par
- \StrBefore{LaTeX}{e}\par
- |\StrBefore{LaTeX}{p}|\par
- |\StrBefore{LaTeX}{L}|\par
- |\StrBefore{a bc def }{def}|\par
- |\StrBefore{a bc def }{cd}|\par
- \StrBefore[1]{1b2b3}{b}\par
- \StrBefore[2]{1b2b3}{b}
-\end{minipage}%
+\showcode-\StrBefore{xstring}{tri}\par
+\StrBefore{LaTeX}{e}\par
+|\StrBefore{LaTeX}{p}|\par
+|\StrBefore{LaTeX}{L}|\par
+|\StrBefore{a bc def }{def}|\par
+|\StrBefore{a bc def }{cd}|\par
+\StrBefore[1]{1b2b3}{b}\par
+\StrBefore[2]{1b2b3}{b}-
\subsubsection{\ttfamily\textbackslash StrBehind}
-\verbinline|\StrBehind|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
+\verb|\StrBehind|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\arguC{nom}
\smallskip
L'argument optionnel \argu{nombre} vaut 1 par défaut.\par\nobreak\smallskip
+
Dans \argu{chaine}, renvoie ce qui se trouve après l'occurrence \no\argu{nombre} de \argu{chaineA}.\medskip
\begin{Conditions}
@@ -628,35 +448,19 @@ Dans \argu{chaine}, renvoie ce qui se trouve après l'occurrence \no\argu{nombre
\item Si l'occurrence n'est pas trouvée, une chaîne vide est renvoyée.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrBehind{xstring}{tri}
-\StrBehind{LaTeX}{e}
-|\StrBehind{LaTeX}{p}|
-|\StrBehind{LaTeX}{X}|
-|\StrBehind{a bc def }{bc}|
-|\StrBehind{a bc def }{cd}|
-\StrBehind[1]{1b2b3}{b}
-\StrBehind[2]{1b2b3}{b}
-|\StrBehind[3]{1b2b3}{b}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrBehind{xstring}{tri}\par
- \StrBehind{LaTeX}{e}\par
- |\StrBehind{LaTeX}{p}|\par
- |\StrBehind{LaTeX}{X}|\par
- |\StrBehind{a bc def }{bc}|\par
- |\StrBehind{a bc def }{cd}|\par
- \StrBehind[1]{1b2b3}{b}\par
- \StrBehind[2]{1b2b3}{b}\par
- |\StrBehind[3]{1b2b3}{b}|
-\end{minipage}%
+\showcode-\StrBehind{xstring}{tri}\par
+\StrBehind{LaTeX}{e}\par
+|\StrBehind{LaTeX}{p}|\par
+|\StrBehind{LaTeX}{X}|\par
+|\StrBehind{a bc def }{bc}|\par
+|\StrBehind{a bc def }{cd}|\par
+\StrBehind[1]{1b2b3}{b}\par
+\StrBehind[2]{1b2b3}{b}\par
+|\StrBehind[3]{1b2b3}{b}-
\subsubsection{\ttfamily\textbackslash StrCut}
Voici la syntaxe de cette macro :\par\nobreak\smallskip
-\verbinline|\StrCut|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{macroA}\ARGU{macroB}
+\verb|\StrCut|\etoile\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}\ARGU{macroA}\ARGU{macroB}
\smallskip
L'argument optionnel \argu{nombre} vaut 1 par défaut.\par\nobreak\smallskip
@@ -669,40 +473,25 @@ Cette macro renvoie \emph{deux chaînes} et donc \textbf{n'affiche rien}. Par co
\item Si \argu{nombre}${}<1$ alors, la macro se comporte comme si \argu{nombre}${}=1$;
\item Si l'occurrence n'est pas trouvée, \argu{macroA} reçoit la totalité de \argu{chaine} tandis que \argu{macroB} est vide.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrCut{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[2]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[3]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[4]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[5]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[6]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut[-4]{abracadabra}{a}\csA\csB |\csA|\csB|\par
-\StrCut{abracadabra}{brac}\csA\csB |\csA|\csB|\par
-\StrCut{abracadabra}{foo}\csA\csB |\csA|\csB|\par
-\StrCut{abracadabra}{}\csA\csB |\csA|\csB|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \def\seprouge{{\color{red}|}}
- \styleexemple
- \StrCut{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[2]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[3]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[5]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[6]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut[-4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
- \StrCut{abracadabra}{brac}\csA\csB |\csA\seprouge\csB|\par
- \StrCut{abracadabra}{foo}\csA\csB |\csA\seprouge\csB|\par
- \StrCut{abracadabra}{}\csA\csB |\csA\seprouge\csB|
-\end{minipage}%
+
+\showcode+\def\seprouge{{\color{red}|}}
+\StrCut{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[2]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[3]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[5]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[6]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut[-4]{abracadabra}{a}\csA\csB |\csA\seprouge\csB|\par
+\StrCut{abracadabra}{brac}\csA\csB |\csA\seprouge\csB|\par
+\StrCut{abracadabra}{foo}\csA\csB |\csA\seprouge\csB|\par
+\StrCut{abracadabra}{}\csA\csB |\csA\seprouge\csB|+
\subsubsection{\ttfamily\textbackslash StrBetween}
-\verbinline|\StrBetween|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
+\verb|\StrBetween|\etoile\arguCC{nombre1}{nombre2}\ARGU{chaine}\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
\smallskip
Les arguments optionnels \argu{nombre1} et \argu{nombre2} valent 1 par défaut.\par\nobreak\smallskip
+
Dans \argu{chaine}, renvoie ce qui se trouve entre\footnote{Au sens strict, c'est-à-dire \emph{sans} les chaînes frontière} les occurrences \no\argu{nombre1} de \argu{chaineA} et \no \argu{nombre2} de \argu{chaineB}.\medskip
\begin{Conditions}
@@ -711,41 +500,23 @@ Dans \argu{chaine}, renvoie ce qui se trouve entre\footnote{Au sens strict, c'es
\item Si l'un des arguments optionnels \argu{nombre1} ou \argu{nombre2} est négatif ou nul, une chaîne vide est renvoyée.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrBetween{xstring}{xs}{ng}
-|\StrBetween{xstring}{i}{n}|
-|\StrBetween{xstring}{a}{tring}|
-|\StrBetween{a bc def }{a}{d}|
-|\StrBetween{a bc def }{a }{f}|
-\StrBetween{a1b1a2b2a3b3}{a}{b}
-\StrBetween[2,3]{a1b1a2b2a3b3}{a}{b}
-\StrBetween[1,3]{a1b1a2b2a3b3}{a}{b}
-|\StrBetween[3,1]{a1b1a2b2a3b3}{a}{b}|
-\StrBetween[3,2]{abracadabra}{a}{bra}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrBetween{xstring}{xs}{ng}\par
- |\StrBetween{xstring}{i}{n}|\par
- |\StrBetween{xstring}{a}{tring}|\par
- |\StrBetween{a bc def }{a}{d}|\par
- |\StrBetween{a bc def }{a }{f}|\par
- \StrBetween{a1b1a2b2a3b3}{a}{b}\par
- \StrBetween[2,3]{a1b1a2b2a3b3}{a}{b}\par
- \StrBetween[1,3]{a1b1a2b2a3b3}{a}{b}\par
- |\StrBetween[3,1]{a1b1a2b2a3b3}{a}{b}|\par
- \StrBetween[3,2]{abracadabra}{a}{bra}\par
-\end{minipage}%
-
-
+\showcode+\StrBetween{xstring}{xs}{ng}\par
+|\StrBetween{xstring}{i}{n}|\par
+|\StrBetween{xstring}{a}{tring}|\par
+|\StrBetween{a bc def }{a}{d}|\par
+|\StrBetween{a bc def }{a }{f}|\par
+\StrBetween{a1b1a2b2a3b3}{a}{b}\par
+\StrBetween[2,3]{a1b1a2b2a3b3}{a}{b}\par
+\StrBetween[1,3]{a1b1a2b2a3b3}{a}{b}\par
+|\StrBetween[3,1]{a1b1a2b2a3b3}{a}{b}|\par
+\StrBetween[3,2]{abracadabra}{a}{bra}+
\subsubsection{\ttfamily\textbackslash StrSubstitute}
-\verbinline|\StrSubstitute|\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\nobreak\smallskip
+
Dans \argu{chaine}, la macro remplace les \argu{nombre} premières occurrences de \argu{chaineA} par \argu{chaineB}, sauf si \argu{nombre}${}=0$ auquel cas, \emph{toutes} les occurrences sont remplacées.
\begin{Conditions}
@@ -756,39 +527,23 @@ Dans \argu{chaine}, la macro remplace les \argu{nombre} premières occurrences d
\item Si \argu{chaineB} est vide, alors les occurrences de \argu{chaineA}, si elles existent, sont supprimées.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrSubstitute{xstring}{i}{a}
-\StrSubstitute{abracadabra}{a}{o}
-\StrSubstitute{abracadabra}{br}{TeX}
-\StrSubstitute{LaTeX}{m}{n}
-\StrSubstitute{a bc def }{ }{M}
-\StrSubstitute{a bc def }{ab}{AB}
-\StrSubstitute[1]{a1a2a3}{a}{B}
-\StrSubstitute[2]{a1a2a3}{a}{B}
-\StrSubstitute[3]{a1a2a3}{a}{B}
-\StrSubstitute[4]{a1a2a3}{a}{B}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrSubstitute{xstring}{i}{a}\par
- \StrSubstitute{abracadabra}{a}{o}\par
- \StrSubstitute{abracadabra}{br}{TeX}\par
- \StrSubstitute{LaTeX}{m}{n}\par
- \StrSubstitute{a bc def }{ }{M}\par
- \StrSubstitute{a bc def }{ab}{AB}\par
- \StrSubstitute[1]{a1a2a3}{a}{B}\par
- \StrSubstitute[2]{a1a2a3}{a}{B}\par
- \StrSubstitute[3]{a1a2a3}{a}{B}\par
- \StrSubstitute[4]{a1a2a3}{a}{B}
-\end{minipage}%
+\showcode|\StrSubstitute{xstring}{i}{a}\par
+\StrSubstitute{abracadabra}{a}{o}\par
+\StrSubstitute{abracadabra}{br}{TeX}\par
+\StrSubstitute{LaTeX}{m}{n}\par
+\StrSubstitute{a bc def }{ }{M}\par
+\StrSubstitute{a bc def }{ab}{AB}\par
+\StrSubstitute[1]{a1a2a3}{a}{B}\par
+\StrSubstitute[2]{a1a2a3}{a}{B}\par
+\StrSubstitute[3]{a1a2a3}{a}{B}\par
+\StrSubstitute[4]{a1a2a3}{a}{B}|
\subsubsection{\ttfamily\textbackslash StrDel}
-\verbinline|\StrDel|\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\nobreak\smallskip
+
Supprime les \argu{nombre} premières occurrences de \argu{chaineA} dans \argu{chaine}, sauf si \argu{nombre}${}=0$ auquel cas, \emph{toutes} les occurrences sont supprimées.\medskip
\begin{Conditions}
@@ -798,28 +553,15 @@ Supprime les \argu{nombre} premières occurrences de \argu{chaineA} dans \argu{c
\item Si \argu{nombre}${}<0$ alors la macro se comporte comme si \argu{nombre}${}=0$;
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrDel{abracadabra}{a}
-\StrDel[1]{abracadabra}{a}
-\StrDel[4]{abracadabra}{a}
-\StrDel[9]{abracadabra}{a}
-\StrDel{a bc def }{ }
-|\StrDel{a bc def }{def}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrDel{abracadabra}{a}\par
- \StrDel[1]{abracadabra}{a}\par
- \StrDel[4]{abracadabra}{a}\par
- \StrDel[9]{abracadabra}{a}\par
- \StrDel{a bc def }{ }\par
- |\StrDel{a bc def }{def}|
-\end{minipage}%
+\showcode+\StrDel{abracadabra}{a}\par
+\StrDel[1]{abracadabra}{a}\par
+\StrDel[4]{abracadabra}{a}\par
+\StrDel[9]{abracadabra}{a}\par
+\StrDel{a bc def }{ }\par
+|\StrDel{a bc def }{def}|+
\subsubsection{\ttfamily\textbackslash StrGobbleLeft}
-\verbinline|\StrGobbleLeft|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrGobbleLeft|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip
Dans \argu{chaine}, enlève les \argu{nombre} premieres \USs de gauche.\medskip
@@ -830,26 +572,14 @@ Dans \argu{chaine}, enlève les \argu{nombre} premieres \USs de gauche.\medskip
\item Si \argu{nombre}${}\geqslant{}$\argu{longueurChaine}, toutes les \USs sont supprimées.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrGobbleLeft{xstring}{2}
-|\StrGobbleLeft{xstring}{9}|
-\StrGobbleLeft{LaTeX}{4}
-\StrGobbleLeft{LaTeX}{-2}
-|\StrGobbleLeft{a bc def }{4}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrGobbleLeft{xstring}{2}\par
- |\StrGobbleLeft{xstring}{9}|\par
- \StrGobbleLeft{LaTeX}{4}\par
- \StrGobbleLeft{LaTeX}{-2}\par
- |\StrGobbleLeft{a bc def }{4}|
-\end{minipage}%
+\showcode+\StrGobbleLeft{xstring}{2}\par
+|\StrGobbleLeft{xstring}{9}|\par
+\StrGobbleLeft{LaTeX}{4}\par
+\StrGobbleLeft{LaTeX}{-2}\par
+|\StrGobbleLeft{a bc def }{4}|+
\subsubsection{\ttfamily\textbackslash StrLeft}
-\verbinline|\StrLeft|\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
@@ -860,74 +590,38 @@ Dans \argu{chaine}, renvoie la sous-chaîne de gauche de longueur \argu{nombre}.
\item Si \argu{nombre}${}\geqslant{}$\argu{longueurChaine}, toutes les \USs sont retournées.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrLeft{xstring}{2}
-\StrLeft{xstring}{9}
-\StrLeft{LaTeX}{4}
-|\StrLeft{LaTeX}{-2}|
-|\StrLeft{a bc def }{5}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrLeft{xstring}{2}\par
- \StrLeft{xstring}{9}\par
- \StrLeft{LaTeX}{4}\par
- |\StrLeft{LaTeX}{-2}|\par
- |\StrLeft{a bc def }{5}|
-\end{minipage}%
+\showcode+\StrLeft{xstring}{2}\par
+\StrLeft{xstring}{9}\par
+\StrLeft{LaTeX}{4}\par
+|\StrLeft{LaTeX}{-2}|\par
+|\StrLeft{a bc def }{5}|+
\subsubsection{\ttfamily\textbackslash StrGobbleRight}
-\verbinline|\StrGobbleRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrGobbleRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip
-Agit comme \verbinline|\StrGobbleLeft|, mais enlève les \USs à droite de \argu{chaine}.
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrGobbleRight{xstring}{2}
-|\StrGobbleRight{xstring}{9}|
-\StrGobbleRight{LaTeX}{4}
-|\StrGobbleRight{LaTeX}{-2}|
-|\StrGobbleRight{a bc def }{4}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrGobbleRight{xstring}{2}\par
- |\StrGobbleRight{xstring}{9}|\par
- \StrGobbleRight{LaTeX}{4}\par
- |\StrGobbleRight{LaTeX}{-2}|\par
- |\StrGobbleRight{a bc def }{4}|
-\end{minipage}%
+Agit comme \verb|\StrGobbleLeft|, mais enlève les \USs à droite de \argu{chaine}.
+
+\showcode+\StrGobbleRight{xstring}{2}\par
+|\StrGobbleRight{xstring}{9}|\par
+\StrGobbleRight{LaTeX}{4}\par
+|\StrGobbleRight{LaTeX}{-2}|\par
+|\StrGobbleRight{a bc def }{4}|+
\subsubsection{\ttfamily\textbackslash StrRight}
-\verbinline|\StrRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrRight|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip
-Agit comme \verbinline|\StrLeft|, mais renvoie les \USs à la droite de \argu{chaine}.
-
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrRight{xstring}{2}
-\StrRight{xstring}{9}
-\StrRight{LaTeX}{4}
-|\StrRight{LaTeX}{-2}|
-\StrRight{a bc def }{5}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrRight{xstring}{2}\par
- \StrRight{xstring}{9}\par
- \StrRight{LaTeX}{4}\par
- |\StrRight{LaTeX}{-2}|\par
- \StrRight{a bc def }{5}
-\end{minipage}%
+Agit comme \verb|\StrLeft|, mais renvoie les \USs à la droite de \argu{chaine}.
+
+\showcode+\StrRight{xstring}{2}\par
+\StrRight{xstring}{9}\par
+\StrRight{LaTeX}{4}\par
+|\StrRight{LaTeX}{-2}|\par
+\StrRight{a bc def }{5}+
\subsubsection{\ttfamily\textbackslash StrChar}
-\verbinline|\StrChar|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
+\verb|\StrChar|\ARGU{chaine}\ARGU{nombre}\arguC{nom}
\smallskip
Renvoie l'\US à la position \argu{nombre} dans la chaîne \argu{chaine}.\medskip
@@ -937,24 +631,13 @@ Renvoie l'\US à la position \argu{nombre} dans la chaîne \argu{chaine}.\medski
\item Si \argu{nombre}${}\leqslant0$ ou si \argu{nombre}${}>{}$\argu{longueurChaine}, aucune \US n'est renvoyée.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrChar{xstring}{4}
-|\StrChar{xstring}{9}|
-|\StrChar{xstring}{-5}|
-\StrChar{a bc def }{6}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrChar{xstring}{4}\par
- |\StrChar{xstring}{9}|\par
- |\StrChar{xstring}{-5}|\par
- \StrChar{a bc def }{6}
-\end{minipage}%
+\showcode+\StrChar{xstring}{4}\par
+|\StrChar{xstring}{9}|\par
+|\StrChar{xstring}{-5}|\par
+\StrChar{a bc def }{6}+
\subsubsection{\ttfamily\textbackslash StrMid}
-\verbinline|\StrMid|\ARGU{chaine}\ARGU{nombre1}\ARGU{nombre2}\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{nombre1} et \argu{nombre2}.\medskip
@@ -968,49 +651,26 @@ Dans \argu{chaine}, renvoie la sous chaîne se trouvant entre\footnote{Au sens l
\item Si \argu{nombre2}${}>{}$\argu{longueurChaine}, alors la macro se comporte comme si \argu{nombre2}${}={}$\argu{longueurChaine}.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrMid{xstring}{2}{5}
-\StrMid{xstring}{-4}{2}
-|\StrMid{xstring}{5}{1}|
-\StrMid{xstring}{6}{15}
-\StrMid{xstring}{3}{3}
-|\StrMid{a bc def }{2}{7}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrMid{xstring}{2}{5}\par
- \StrMid{xstring}{-4}{2}\par
- |\StrMid{xstring}{5}{1}|\par
- \StrMid{xstring}{6}{15}\par
- \StrMid{xstring}{3}{3}\par
- |\StrMid{a bc def }{2}{7}|
-\end{minipage}%
+\showcode+\StrMid{xstring}{2}{5}\par
+\StrMid{xstring}{-4}{2}\par
+|\StrMid{xstring}{5}{1}|\par
+\StrMid{xstring}{6}{15}\par
+\StrMid{xstring}{3}{3}\par
+|\StrMid{a bc def }{2}{7}|+
\subsection{Les macros renvoyant des nombres}
\subsubsection{\ttfamily\textbackslash StrLen}
-\verbinline|\StrLen|\ARGU{chaine}\arguC{nom}
+\verb|\StrLen|\ARGU{chaine}\arguC{nom}
\smallskip
Renvoie la longueur de \argu{chaine}.
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrLen{xstring}
-\StrLen{A}
-\StrLen{a bc def }
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrLen{xstring}\par
- \StrLen{A}\par
- \StrLen{a bc def }
-\end{minipage}%
+\showcode+\StrLen{xstring}\par
+\StrLen{A}\par
+\StrLen{a bc def }+
\subsubsection{\ttfamily\textbackslash StrCount}
-\verbinline|\StrCount|\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
@@ -1019,27 +679,17 @@ Compte combien de fois \argu{chaineA} est contenue dans \argu{chaine}.\par\medsk
\item Si l'un au moins des arguments \argu{chaine} ou \argu{chaineA} est vide, la macro renvoie 0.
\end{Conditions}
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrCount{abracadabra}{a}
-\StrCount{abracadabra}{bra}
-\StrCount{abracadabra}{tic}
-\StrCount{aaaaaa}{aa}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrCount{abracadabra}{a}\par
- \StrCount{abracadabra}{bra}\par
- \StrCount{abracadabra}{tic}\par
- \StrCount{aaaaaa}{aa}
-\end{minipage}%
+\showcode+\StrCount{abracadabra}{a}\par
+\StrCount{abracadabra}{bra}\par
+\StrCount{abracadabra}{tic}\par
+\StrCount{aaaaaa}{aa}+
\subsubsection{\ttfamily\textbackslash StrPosition}
-\verbinline|\StrPosition|\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\nobreak\smallskip
+
Dans \argu{chaine}, renvoie la position de l'occurrence \no\argu{nombre} de \argu{chaineA}.\medskip
\begin{Conditions}
@@ -1048,119 +698,69 @@ Dans \argu{chaine}, renvoie la position de l'occurrence \no\argu{nombre} de \arg
\end{Conditions}
\medskip
-\begin{minipage}[t]{0.65\linewidth}
-\begin{lstlisting}
-\StrPosition{xstring}{ring}
-\StrPosition[4]{abracadabra}{a}
-\StrPosition[2]{abracadabra}{bra}
-\StrPosition[9]{abracadabra}{a}
-\StrPosition{abracadabra}{z}
-\StrPosition{a bc def }{d}
-\StrPosition[3]{aaaaaa}{aa}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \StrPosition{xstring}{ring}\par
- \StrPosition[4]{abracadabra}{a}\par
- \StrPosition[2]{abracadabra}{bra}\par
- \StrPosition[9]{abracadabra}{a}\par
- \StrPosition{abracadabra}{z}\par
- \StrPosition{a bc def }{d}\par
- \StrPosition[3]{aaaaaa}{aa}
-\end{minipage}%
+\showcode+\StrPosition{xstring}{ring}\par
+\StrPosition[4]{abracadabra}{a}\par
+\StrPosition[2]{abracadabra}{bra}\par
+\StrPosition[9]{abracadabra}{a}\par
+\StrPosition{abracadabra}{z}\par
+\StrPosition{a bc def }{d}\par
+\StrPosition[3]{aaaaaa}{aa}+
\subsubsection{\ttfamily\textbackslash StrCompare}
-\verbinline|\StrCompare|\etoile\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
+\verb|\StrCompare|\etoile\ARGU{chaineA}\ARGU{chaineB}\arguC{nom}
\smallskip
-Cette macro peut fonctionner avec 2 tolérances, la tolérance \guill{normale} qui est sélectionnée par défaut et la tolérance \guill{stricte}.\medskip
+Cette macro peut fonctionner avec 2 tolérances, la tolérance \guill{normale} qui est sélectionnée par défaut et la tolérance \guill{stricte}.
\begin{itemize}
- \item La tolérance normale, activée par la commande \verbinline|\comparenormal|.\par
+ \item La tolérance normale, activée par la commande \verb|\comparenormal|.\par
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 \verbinline|\comparestrict|.\par
+ \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}
-\smallskip
-
-L'ordre des 2 chaînes n'a aucune influence sur le comportement de la macro.
+\medskip
-\medskip On peut également mémoriser le mode de comparaison en cours avec \verbinline|\savecomparemode|, le modifier par la suite et revenir à la situation lors de la sauvegarde avec \verbinline|\restorecomparemode|.\medskip
+On peut également mémoriser le mode de comparaison en cours avec \verb|\savecomparemode|, le modifier par la suite et revenir à la situation lors de la sauvegarde avec \verb|\restorecomparemode|.\medskip
Exemples en tolérance normale :\par\nobreak
-\begin{minipage}[t]{0.65\linewidth}
+\showcode+
\comparenormal
-\begin{lstlisting}
-\StrCompare{abcd}{abcd}
-\StrCompare{abcd}{abc}
-\StrCompare{abc}{abcd}
-\StrCompare{a b c}{abc}
-\StrCompare{aaa}{baaa}
-\StrCompare{abc}{xyz}
-\StrCompare{123456}{123457}
-\StrCompare{abc}{}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \comparenormal
- \StrCompare{abcd}{abcd}\par
- \StrCompare{abcd}{abc}\par
- \StrCompare{abc}{abcd}\par
- \StrCompare{a b c}{abc}\par
- \StrCompare{aaa}{baaa}\par
- \StrCompare{abc}{xyz}\par
- \StrCompare{123456}{123457}\par
- \StrCompare{abc}{}
-\end{minipage}%
-\medskip
+\StrCompare{abcd}{abcd}\par
+\StrCompare{abcd}{abc}\par
+\StrCompare{abc}{abcd}\par
+\StrCompare{a b c}{abc}\par
+\StrCompare{aaa}{baaa}\par
+\StrCompare{abc}{xyz}\par
+\StrCompare{123456}{123457}\par
+\StrCompare{abc}{}+
Exemples en tolérance stricte :\par\nobreak
-\begin{minipage}[t]{0.65\linewidth}
-\comparestrict
-\begin{lstlisting}
-\StrCompare{abcd}{abcd}
-\StrCompare{abcd}{abc}
-\StrCompare{abc}{abcd}
-\StrCompare{a b c}{abc}
-\StrCompare{aaa}{baaa}
-\StrCompare{abc}{xyz}
-\StrCompare{123456}{123457}
-\StrCompare{abc}{}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[t]{0.35\linewidth}
- \styleexemple
- \comparestrict
- \StrCompare{abcd}{abcd}\par
- \StrCompare{abcd}{abc}\par
- \StrCompare{abc}{abcd}\par
- \StrCompare{a b c}{abc}\par
- \StrCompare{aaa}{baaa}\par
- \StrCompare{abc}{xyz}\par
- \StrCompare{123456}{123457}\par
- \StrCompare{abc}{}
-\end{minipage}%
+\showcode+\comparestrict
+\StrCompare{abcd}{abcd}\par
+\StrCompare{abcd}{abc}\par
+\StrCompare{abc}{abcd}\par
+\StrCompare{a b c}{abc}\par
+\StrCompare{aaa}{baaa}\par
+\StrCompare{abc}{xyz}\par
+\StrCompare{123456}{123457}\par
+\StrCompare{abc}{}+
\section{Modes de fonctionnement}
\subsection{Développement des arguments}
\label{devarg}
-\lstset{basicstyle=\footnotesize\ttfamily}
\subsubsection{Les macros {\ttfamily \textbackslash fullexpandarg}, {\ttfamily \textbackslash expandarg} et {\ttfamily \textbackslash noexpandarg}}
-La macro \verbinline|\fullexpandarg| est appelée par défaut, ce qui fait que certains arguments (en \textcolor{violet}{violet} dans la liste ci dessous) transmis aux macros sont développés le plus possible (pour cela, un \verb|\edef| est utilisé). Ce mode de développement maximal permet dans la plupart des cas d'éviter d'utiliser des chaînes d'\verb|\expandafter|. Le code en est souvent allégé.
+La macro \verb|\fullexpandarg| est appelée par défaut, ce qui fait que certains arguments (en \textcolor{violet}{violet} dans la liste ci dessous) transmis aux macros sont développés le plus possible (pour cela, un \verb|\edef| est utilisé). Ce mode de développement maximal permet dans la plupart des cas d'éviter d'utiliser des chaînes d'\verb|\expandafter|. Le code en est souvent allégé.
-On peut interdire le développement de ces arguments (et ainsi revenir au comportement normal de \TeX) en invoquant \verbinline|\noexpandarg| ou \verbinline|\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 de ces arguments que l'on appelle avec \verbinline|\expandarg|. Dans ce cas, le \textbf{premier token} de ces arguments est développé \emph{une fois} avant que la macro ne soit appelée. Si l'argument contient plus d'un token, les tokens qui suivent le premier ne sont pas développés (on peut contourner cette volontaire limitation et utiliser la macro \verbinline|\StrExpand|, 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 token} de ces arguments est développé \emph{une fois} avant que la macro ne soit appelée. Si l'argument contient plus d'un token, les tokens qui suivent le premier ne sont pas développés (on peut contourner cette volontaire limitation et utiliser la macro \verb|\StrExpand|, voir page~\pageref{scancs}).\medskip
-Les commandes \verbinline|\fullexpandarg|, \verbinline|\noexpandarg|, \verbinline|\normalexpandarg| et \verbinline|\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
+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 \verbinline|\saveexpandmode|, le modifier par la suite et revenir à la situation lors de la sauvegarde avec \verbinline|\restoreexpandmode|.\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|.\medskip
-Dans la liste ci-dessous, on peut voir en \textcolor{violet}{violet} quels arguments sont soumis à l'éventuel développement pour chaque macro vue dans le chapitre précedent :
+Dans la liste ci-dessous, on peut voir en \textcolor{violet}{violet} quels arguments sont soumis à l'éventuel développement pour chaque macro vue dans le chapitre précedent :\smallskip
-\nobreak\smallskip
\parindent3em
\begin{itemize}
\item\verb|\IfSubStr|\etoile{\colorise\arguC{nombre}\ARGU{chaine}\ARGU{chaineA}}\ARGU{vrai}\ARGU{faux}
@@ -1204,36 +804,25 @@ Dans la liste ci-dessous, on peut voir en \textcolor{violet}{violet} quels argum
\subsubsection{Caractères et lexèmes autorisés dans les arguments}
Tout d'abord, quelque soit le mode de développement choisi, \textbf{les tokens de catcode 6 et 14 (habituellement {\ttfamily\#} et {\ttfamily\%}) sont interdits dans tous les arguments}\footnote{Le token {\ttfamily\#} sera peut-être autorisé dans une future version !}.\bigskip
-Lorsque le mode \verbinline|\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 :
-
-\nobreak\smallskip\parindent3em
+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 :
+\parindent3em
\begin{itemize}
\item les lettres, majuscules, minuscules, accentuées\footnote{Pour pouvoir utiliser des lettres accentuées de façon fiable, il est nécessaire de charger le packages \texttt{\string\fontenc} avec l'option \texttt{[T1]}, ainsi que \texttt{\string\inputenc} avec l'option correspondant au codage du fichier tex.} ou non, les chiffres, les espaces\footnote{Selon la règle \TeX{}iènne, plusieurs espaces consécutifs n'en font qu'un.} ainsi que tout autre token de catcode 10, 11 ou 12 (signes de ponctuation, signes opératoires mathématiques, parenthèses, crochets, etc);
\item les tokens de catcode 1 à 4, qui sont habituellement : \og\verb|{|\fg\quad\og\verb|}|\fg\footnote{Attention : les accolades \textbf{doivent} être équilibrées dans les arguments !}\quad\og\verb|$|\fg\quad\og\verb|&|\fg
\item les tokens de catcode 7 et 8, qui sont habituellement : \og\verb|^|\fg\quad\og\verb|_|\fg
- \item toute séquence de contrôle si elle est purement développable\footnote{C'est-à-dire qu'elle peut être mise à l'intérieur d'un {\ttfamily\string\edef }.} et dont le développement maximal donne des caractères autorisés;
- \item un token de catcode 13 (caractère actif) s'il est purement développable.
+ \item toute séquence de contrôle si elle est purement développable\footnote{C'est-à-dire qu'elle peut être mise à l'intérieur d'un {\ttfamily\string\edef }.} et dont le développement maximal donne des caractères autorisés.
\end{itemize}
\parindent0pt\smallskip
-Lorsque les arguments ne sont plus développés (utilisation de \verbinline|\noexpandarg|), on peut aussi inclure dans les arguments n'importe quel token, quelque soit le code qui en résulte comme par exemple toute séquence de contrôle, même non définie ou tout token de catcode 13. On peut également inclure dans les arguments des tokens de test comme \verbinline|\if| ou \verbinline|\ifx| ou tout autre token de test, même sans leur \verbinline|\fi| correspondant; ou bien un \verbinline|\csname| sans le \verbinline|\endcsname| correspondant.
+Lorsque les arguments ne sont plus développés (utilisation de \verb|\noexpandarg|), on peut aussi inclure dans les arguments n'importe quel token, quelque soit le code qui en résulte comme par exemple toute séquence de contrôle, même non définie ou tout token de catcode 13. On peut également inclure dans les arguments des tokens de test comme \verb|\if| ou \verb|\ifx| ou tout autre token de test, même sans leur \verb|\fi| correspondant; ou bien un \verb|\csname| sans le \verb|\endcsname| correspondant.
-Dans l'exemple suivant, l'argument contient un \verbinline|\ifx| \emph{sans} le \verbinline|\fi|, et l'on isole ce qui est entre le \verbinline|\ifx| et le \verbinline|\else| :\par\medskip\nobreak
+Dans l'exemple suivant, l'argument contient un \verb|\ifx| \emph{sans} le \verb|\fi|, et l'on isole ce qui est entre le \verb|\ifx| et le \verb|\else| :\par\medskip\nobreak
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
-\StrBetween{\ifx ab faux \else vrai}{\ifx}{\else}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \StrBetween{\ifx ab faux \else vrai}{\ifx}{\else}
-\end{minipage}
+\showcode+\noexpandarg
+\StrBetween{\ifx ab faux \else vrai}{\ifx}{\else}+
\medskip
-Lorsqu'on utilise \verbinline|\expandarg|, la précaution concerne le premier token qui est développé une fois et doit donc être défini. Les autres tokens sont laissés tel quels comme avec \verbinline|\noexpandarg|.
+Lorsqu'on utilise \verb|\expandarg|, la précaution concerne le premier token qui est développé une fois et doit donc être défini. Les autres tokens sont laissés tel quels comme avec \verb|\noexpandarg|.
\subsection{Développement des macros, argument optionnel}
\label{argumentoptionnel}
@@ -1242,15 +831,15 @@ Les macros de ce package ne sont pas purement développables et ne peuvent donc
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\nobreak
-\hspace{0.2\linewidth}\verbinline|\edef\Resultat{\StrLeft{xstring}{4}}|\par\nobreak
+\hspace{0.2\linewidth}\verb|\edef\Resultat{\StrLeft{xstring}{4}}|\par\nobreak
\qquad est équivalente à :\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrLeft{xstring}{4}[\Resultat]|\medskip
+\hspace{0.2\linewidth}\verb|\StrLeft{xstring}{4}[\Resultat]|\medskip
Et cette imbrication non permise censée enlever le premier et le dernier caractère de \verb|xstring| :\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrGobbleLeft{\StrGobbleRight{xstring}{1}}{1}|\par\nobreak
+\hspace{0.2\linewidth}\verb|\StrGobbleLeft{\StrGobbleRight{xstring}{1}}{1}|\par\nobreak
\qquad se programme ainsi :\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrGobbleRight{xstring}{1}[\machaine]|\par\nobreak
-\hspace{0.2\linewidth}\verbinline|\StrGobbleLeft{\machaine}{1}|\par
+\hspace{0.2\linewidth}\verb|\StrGobbleRight{xstring}{1}[\machaine]|\par\nobreak
+\hspace{0.2\linewidth}\verb|\StrGobbleLeft{\machaine}{1}|\par
\subsection{Traitement des arguments}
\label{developpementarguments}
@@ -1267,53 +856,30 @@ Voyons ce qu'est la notion d'\US sur un exemple. Prenons cet argument : \og\verb
\nobreak Il contient 6 \USs qui sont : \og\verb|a|\fg, \og\verb|b|\fg, \og\verb|\textbf|\fg, \og\verb|{xyz}|\fg, \og\verb|c|\fg{} et \og\verb|d|\fg.
-\nobreak\medskip Que va t-il arriver si l'on se place sous \verbinline|\noexpandarg| et que l'on demande à \Xstring de trouver la longueur de cet argument et d'en trouver le 4\ieme{} \guill{caractère} ?\medskip
+\nobreak\medskip Que va t-il arriver si l'on se place sous \verb|\noexpandarg| et que l'on demande à \Xstring de trouver la longueur de cet argument et d'en trouver le 4\ieme{} \guill{caractère} ?\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
+\showcode+\noexpandarg
\StrLen{ab\textbf{xyz}cd}\par
\StrChar{ab\textbf{xyz}cd}{4}[\mychar]
-\meaning\mychar
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \StrLen{ab\textbf{xyz}cd}\par
- \StrChar{ab\textbf{xyz}cd}{4}[\mychar]
- \meaning\mychar
-\end{minipage}%
+\meaning\mychar+
\fullexpandarg
\medskip
Il est nécessaire d'utiliser \verb|\meaning| pour bien visualiser le véritable contenu de \verb|\mychar| et non pas de simplement d'appeler cette séquence de contrôle, ce qui fait perdre des informations ---~les accolades ici. On voit qu'on n'obtient pas vraiment un \guill{caractère}, mais cela était prévisible : il s'agit d'une \US.
\subsubsection{Exploration des groupes}
-Par défaut, la commande \verbinline|\noexploregroups| est appelée et donc dans l'argument à examiner qui contient la chaîne de tokens, \Xstring considère les groupes entre accolades comme \USs fermées dans lesquelles \Xstring ne regarde pas.
+Par défaut, la commande \verb|\noexploregroups| est appelée et donc dans l'argument à examiner qui contient la chaîne de tokens, \Xstring considère les groupes entre accolades comme \USs fermées dans lesquelles \Xstring ne regarde pas.
-Pour certains besoins spécifiques, il peut être nécessaire de modifier le mode de lecture des arguments et d'explorer l'intérieur des groupes entre accolades. Pour cela on peut invoquer \verbinline|\exploregroups|.\medskip
+Pour certains besoins spécifiques, il peut être nécessaire de modifier le mode de lecture des arguments et d'explorer l'intérieur des groupes entre accolades. Pour cela on peut invoquer \verb|\exploregroups|.\medskip
Que va donner ce nouveau mode d'exploration sur l'exemple précédent ? \Xstring ne va plus compter le groupe comme une seule \US mais va compter les \USs se trouvant à l'intérieur, et ainsi de suite s'il y avait plusieurs niveaux d'imbrication de groupes:
\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
+\showcode+\noexpandarg
\exploregroups
\StrLen{ab\textbf{xyz}cd}\par
\StrChar{ab\textbf{xyz}cd}{4}[\mychar]
-\meaning\mychar
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \exploregroups
- \StrLen{ab\textbf{xyz}cd}\par
- \StrChar{ab\textbf{xyz}cd}{4}[\mychar]
- \meaning\mychar
-\end{minipage}%
+\meaning\mychar+
\fullexpandarg\noexploregroups
\medskip
@@ -1321,13 +887,16 @@ L'exploration des groupes peut se réveler utile pour le comptage, le calcul de
Voyons ce que cela signifie sur un exemple : mettons que l'on veuille renvoyer ce qui se trouve à droite de la 2\ieme{} occurrence de \verb|\a| dans l'argument \verb|\a1{\b1\a2}\a3|. Comme l'on explore les groupes, cette occurrence se trouve à l'intérieur du groupe \verb|{\b1\a2}|. Le résultat renvoyé sera donc : \verb|\b1|. Vérifions-le :
+\showcode+\noexpandarg
+\exploregroups
+\StrBefore[2]{\a1{\b1\a2}\a3}{\a}[\mycs]
+\meaning\mycs+
+L'exploration des groupes\footnote{On peut consulter le fichier de test de \Xstring qui comporte de nombreux exemples et met en évidence les différences selon le mode d'exploration des groupes.} peut ainsi changer le comportement de la plupart des macros de \Xstring, à l'exception de \verb|\IfInteger|, \verb|\IfDecimal|, \verb|\IfStrEq|, \verb|\IfEq| 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 \verbinline|\IfInteger|, \verbinline|\IfDecimal|, \verbinline|\IfStrEq|, \verbinline|\IfEq| et \verbinline|\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 \verbinline|\noexploregroups|, quelque soit le mode d'exploration en cours : \verbinline|\StrBetween| et \verbinline|\StrMid|.\medskip
+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 \verbinline|\saveexploremode|, le modifier par la suite et revenir à la situation lors de la sauvegarde avec \verbinline|\restoreexploremode|.
+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 et macros étoilées}
\label{macrosetoilees}
@@ -1340,26 +909,15 @@ ne se développent pas en 2 arguments égaux aux yeux de \Xstring. Dans le premi
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\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\IfStrEq{\string a\string b}{ab}{vrai}{faux}\par
-\IfStrEq*{\string a\string b}{ab}{vrai}{faux}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \IfStrEq{\string a\string b}{ab}{vrai}{faux}\par
- \IfStrEq*{\string a\string b}{ab}{vrai}{faux}
-\end{minipage}%
+\showcode+\IfStrEq{\string a\string b}{ab}{vrai}{faux}\par
+\IfStrEq*{\string a\string b}{ab}{vrai}{faux}+
\smallskip
Les chaînes n'étant pas égales à cause des catcodes, le test est bien \emph{négatif} dans la version non étoilée.\bigskip
\textbf{Attention} : utiliser une macro étoilée a des conséquenses ! Les arguments sont \guill{détokénisés}, il n'y a donc plus de séquence de contrôle, plus de goupes, ni aucun caractère de catcode spécial puisque tout est converti en caractères \guill{inoffensifs} ayant le même catcode.\medskip
-Ainsi, pour les macros renvoyant une chaîne, si on emploie les versions étoilées, le résultat sera une chaîne de caractères dont les catcodes sont 12, et 10 pour l'espace.
-
-Et donc, après un \og\verbinline|\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
+Ainsi, pour les macros renvoyant une chaîne, si on emploie les versions étoilées, le résultat sera une chaîne de caractères dont les catcodes sont 12, et 10 pour l'espace. Et donc, après un \og\verb|\StrBefore*{a \b c d}{c}[\montexte]|\fg{}, la séquence de contrôle \verb|\montexte| se développera en \og{}\verb|a|${}_{12}$\verb*| |${}_{10}$\verb|\|${}_{12}$\verb|b|${}_{12}$\verb*| |${}_{10}$\fg{}.\medskip
Les macros détokenisant leur arguments par l'utilisation de l'étoile sont présentées dans la liste ci-dessous. Pour chacune d'entre elles, on peut voir en \textcolor{violet}{violet} quels arguments seront détokenisé lorsque l'étoile sera employée :
@@ -1392,10 +950,10 @@ Les macros détokenisant leur arguments par l'utilisation de l'étoile sont pré
\section{Macros avancées pour la programmation}
Bien que \Xstring ait la possibilité de lire et traiter des arguments contenant du code \TeX{} ou \LaTeX{} ce qui devrait couvrir la plupart des besoins en programmation, il peut arriver pour des besoins très spécifiques que les macros décritesz précédemment ne suffisent pas. Ce chapitre présente d'autres macros qui permettent d'aller plus loin ou de contourner certaines limitations.
\subsection{Recherche d'un groupe, les macros {\ttfamily\textbackslash StrFindGroup} et {\ttfamily\textbackslash groupID}}
-Lorsque le mode \verbinline=\exploregroups= est actif, la macro \verbinline=\StrFindGroup= permet de trouver un groupe entre accolades explicites en spécifiant son identifiant :
+Lorsque le mode \verb=\exploregroups= est actif, la macro \verb=\StrFindGroup= permet de trouver un groupe entre accolades explicites en spécifiant son identifiant :
\nobreak\smallskip
-\verbinline|\StrFindGroup|\ARGU{argument}\ARGU{identifiant}\arguC{nom}\medskip
+\verb|\StrFindGroup|\ARGU{argument}\ARGU{identifiant}\arguC{nom}\medskip
Lorsque le groupe caractérisé par l'identifiant n'existe pas, une chaîne vide sera assignée à la séquence de contrôle \argu{nom}. Si le groupe existe, ce groupe \emph{avec ses accolades} sera assigné à \argu{nom}.\smallskip
@@ -1422,9 +980,7 @@ Dans cet exemple :
\parindent0pt
\medskip
Voici l'exemple complet :\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\exploregroups
+\showcode+\exploregroups
\expandarg
\def\chaine{a{{bc}d{efg}}h{{ij}{k}{l{m}{no}}p}}
\StrFindGroup{\chaine}{1}[\mongroupe]
@@ -1434,33 +990,15 @@ Voici l'exemple complet :\par\nobreak\smallskip
\StrFindGroup{\chaine}{2,3,2}[\mongroupe]
\meaning\mongroupe\par
\StrFindGroup{\chaine}{2,5}[\mongroupe]
-\meaning\mongroupe\par
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \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}%
+\meaning\mongroupe+
\bigskip
-Le processus inverse existe, et plusieurs macros de \Xstring donnent aussi comme information l'identifiant du groupe dans lequel elles ont fait une coupure ou trouvé une recherche. Ces macros sont : \verbinline|\IfSubStr|, \verbinline|\StrBefore|, \verbinline|\StrBehind|, \verbinline|\StrSplit|, \verbinline|\StrLeft|, \verbinline|\StrGobbleLeft|, \verbinline|\StrRight|, \verbinline|\StrGobbleRight|, \verbinline|\StrChar|, \verbinline|\StrPosition|.\medskip
+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 \verbinline|\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, \verbinline|\groupID| est vide. Évidemment, l'utilisation de \verbinline|\groupID| n'a de sens que lorsque le mode \verbinline|\exploregroups| est actif, et quand les macros ne sont pas étoilées.\smallskip
+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 \verbinline|\StrChar| :\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\exploregroups
+Voici quelques exemples avec la macro \verb|\StrChar| :\par\nobreak\smallskip
+\showcode+\exploregroups
char 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
\string\groupID = \groupID\par
char 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
@@ -1468,26 +1006,13 @@ char 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
char 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
\string\groupID = \groupID\par
char 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
-\string\groupID = \groupID
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \exploregroups
- char 1 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{1}\qquad
- \string\groupID = \groupID\par
- char 4 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{4}\qquad
- \string\groupID = \groupID\par
- char 6 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{6}\qquad
- \string\groupID = \groupID\par
- char 20 = \StrChar{a{b{cd}{e{f}g}h}ijkl}{20}\qquad
- \string\groupID = \groupID
-\end{minipage}
+\string\groupID = \groupID+
\subsection{Coupure d'une chaîne, la macro {\ttfamily\textbackslash StrSplit}}
\label{StrSplit}
Voici la syntaxe de cette macro :\par\nobreak\smallskip
-\verbinline|\StrSplit|\ARGU{chaine}\ARGU{nombre}\ARGU{chaineA}\ARGU{chaineB}
+
+\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
@@ -1499,57 +1024,24 @@ Cette macro renvoie \emph{deux chaînes} et donc \textbf{n'affiche rien}. Par co
\item Si \argu{chaine} est vide \argu{chaineA} et \argu{chaineB} seront vides, quelque soit l'entier \argu{nombre}.
\end{Conditions}
-\begin{minipage}[c]{0.65\linewidth}
-\hfill
-\begin{lstlisting}
-\def\seprouge{{\color{red}|}}
+\showcode+\def\seprouge{{\color{red}|}}
\StrSplit{abcdef}{4}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{a b c }{2}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{abcdef}{1}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{abcdef}{5}{\csA}{\csB}|\csA\seprouge\csB|\par
\StrSplit{abcdef}{9}{\csA}{\csB}|\csA\seprouge\csB|\par
-\StrSplit{abcdef}{-3}{\csA}{\csB}|\csA\seprouge\csB|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
-\styleexercice
-\def\seprouge{{\color{red}|}}
-\StrSplit{abcdef}{4}{\csA}{\csB}|\csA\seprouge\csB|\par
-\StrSplit{a b c }{2}{\csA}{\csB}|\csA\seprouge\csB|\par
-\StrSplit{abcdef}{1}{\csA}{\csB}|\csA\seprouge\csB|\par
-\StrSplit{abcdef}{5}{\csA}{\csB}|\csA\seprouge\csB|\par
-\StrSplit{abcdef}{9}{\csA}{\csB}|\csA\seprouge\csB|\par
-\StrSplit{abcdef}{-3}{\csA}{\csB}|\csA\seprouge\csB|
-\end{minipage}%
-
-\setverbdelim{|}\medskip
+\StrSplit{abcdef}{-3}{\csA}{\csB}|\csA\seprouge\csB|+
-Lorsque l'exploration des groupes est activée, et que l'on demande une coupure en fin de groupe, alors une chaîne contiendra la totalité du groupe tansque l'autre sera vide comme on le voit sur cet exemple :\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\hfill
-\begin{lstlisting}
-\exploregroups
+Lorsque l'exploration des groupes est activée, et que l'on demande une coupure en fin de groupe, alors une chaîne contiendra la totalité du groupe tandis que l'autre sera vide comme on le voit sur cet exemple :\par\nobreak\smallskip
+\showcode+\exploregroups
\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
-\meaning\strB
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \exploregroups
- \StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
- \meaning\strA\par
- \meaning\strB
-\end{minipage}%
-\medskip
+\meaning\strB+\medskip
-Une version étoilée de cette macro existe : dans ce cas, la coupure se fait juste avant la prochaine \US qui suit l'\US désirée. La version étoilée ne donne des résultats différents de la version normale que lorsque la $n$\ieme{} \US est à la fin d'un groupe auquel cas, la coupure intervient non pas après cette \US mais \emph{avant} la prochaine \US, que \verbinline|\StrSplit| atteint en fermant autant de groupes que nécessaire.\smallskip
+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}[c]{0.65\linewidth}
-\hfill
-\begin{lstlisting}
-\exploregroups
-Utilisation sans \'etoile :\par
+\showcode+\exploregroups
+Utilisation sans étoile :\par
\StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
\meaning\strB\par
@@ -1558,40 +1050,22 @@ Utilisation avec \'etoile :\par
\StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
\meaning\strA\par
\meaning\strB\par
-\string\groupID\ = \groupID
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \exploregroups
- Utilisation sans étoile :\par
- \StrSplit{ab{cd{ef}gh}ij}{6}\strA\strB
- \meaning\strA\par
- \meaning\strB\par
- \string\groupID\ = \groupID\par\medskip
- Utilisation avec \'etoile :\par
- \StrSplit*{ab{cd{ef}gh}ij}{6}\strA\strB
- \meaning\strA\par
- \meaning\strB\par
- \string\groupID\ = \groupID
-\end{minipage}%
+\string\groupID\ = \groupID+
\subsection{Assigner un contenu verb, la macro \ttfamily\textbackslash verbtocs}
\label{verbtocs}
-La macro \verbinline|\verbtocs| permet le lire le contenu d'un \guill{verb} qui peut contenir tous les caractères spéciaux : \verb|&|, \verb|~|, \verb|\|, \verb|{|, \verb|}|, \verb|_|, \verb|#|, \verb|$|, \verb|^| et \verb|%|. Les caractères \guill{normaux} gardent leur catcodes naturels, sauf les caractères spéciaux qui prennent un catcode de 12. Ensuite, ces caractères sont assignés à une séquence de contrôle. La syntaxe complète est :\par\nobreak\medskip
-\hfill\verbinline|\verbtocs|\ARGU{nom}|\argu{caractères}|\hfill{}
+La macro \verb|\verbtocs| permet le lire le contenu d'un \guill{verb} qui peut contenir tous les caractères spéciaux : \verb|&|, \verb|~|, \verb|\|, \verb|{|, \verb|}|, \verb|_|, \verb|#|, \verb|$|, \verb|^| et \verb|%|. Les caractères \guill{normaux} gardent leur catcodes naturels, sauf les caractères spéciaux qui prennent un catcode de 12. Ensuite, ces caractères sont assignés à une séquence de contrôle. La syntaxe complète est :\par\nobreak\medskip
+\hfill\verb|\verbtocs|\ARGU{nom}|\argu{caractères}|\hfill{}
\smallskip
\argu{nom} est le nom d'une séquence de contrôle qui recevra à l'aide d'un \verb|\edef| les \argu{caractères}. \argu{nom} contiendra donc des caractères de catcodes 12 ou 10 pour l'espace.\medskip
Par défaut, le token délimitant le contenu verb est \guill{|}, étant entendu que ce token ne peut être à 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 token délimitant le contenu verb par la macro :\par\medskip
-\hfill\verbinline|\setverbdelim|\ARGU{token}\hfill{}\smallskip
+\hfill\verb|\setverbdelim|\ARGU{token}\hfill{}\smallskip
Tout \argu{token} de catcode 12 peut être utilisé\footnote{Plusieurs tokens peuvent être utilisés au risque d'alourdir la syntaxe de \texttt{\string\verbtocs} ! Pour cette raison, avertissement sera émis si l'argument de \texttt{\string\setverbdelim} contient plusieurs tokens.}.\medskip
Concernant ces arguments verb, il faut tenir compte des deux points suivants :
-
-\nobreak
\begin{itemize}
\item tous les caractères se trouvant avant |\argu{caractères}| seront ignorés;
\item à l'intérieur des délimiteurs, tous les espaces sont comptabilisés même s'ils sont consécutifs.
@@ -1599,63 +1073,40 @@ Concernant ces arguments verb, il faut tenir compte des deux points suivants :
\medskip
Exemple :\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\lstset{deletecomment=[l]\%}
-\begin{lstlisting}
-\verbtocs{\resultat} |a & b{ c% d$ e \f|
-J'affiche le r\'esultat :\par\resultat
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\resultat} |a & b{ c% d$ e \f|
- J'affiche le r\'esultat :\par\resultat
-\end{minipage}%
+\showcode+\verbtocs{\resultat} |a & b{ c% d$ e \f|
+J'affiche le résultat :\par\resultat+
\subsection{Tokenisation d'un texte vers une séquence de contrôle, la macro \ttfamily\textbackslash tokenize}
Le processus inverse de ce qui a été vu au dessus consiste à interpréter une suite de caractères en tokens. Pour cela, on dispose de la macro :\par\nobreak\medskip
-\hfill\verbinline|\tokenize|\ARGU{nom}\ARGU{texte}\hfill{}
+\hfill\verb|\tokenize|\ARGU{nom}\ARGU{texte}\hfill{}
\smallskip
-\argu{texte} est développé le plus possible si l'on a invoqué \verbinline|\fullexpandarg|; il n'est pas développé si l'on a invoqué \verbinline|\noexpandarg| ou \verbinline|\expandarg|. Après développement éventuel, le \argu{texte} est transformé en tokens puis assigné à l'aide d'un \verb|\def| à la séquence de contrôle \argu{nom}.\medskip
+\argu{texte} est développé le plus possible si l'on a invoqué \verb|\fullexpandarg|; il n'est pas développé si l'on a invoqué une des commandes \verb|\noexpandarg| ou \verb|\expandarg|. Après développement éventuel, le \argu{texte} est transformé en tokens puis assigné à 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\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\verbtocs{\text}|\textbf{a} $\frac{1}{2}$|
+\showcode+\verbtocs{\text}|\textbf{a} $\frac{1}{2}$|
texte : \text
\tokenize{\resultat}{\text}\par
-r\'esultat : \resultat
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\text}|\textbf{a} $\frac{1}{2}$|
- texte : \text
- \tokenize{\resultat}{\text} \par
- r\'esultat : \resultat
-\end{minipage}%
+réesultat : \resultat+
\medskip
Il est bien évident à la dernière ligne, que l'appel à la séquence de contrôle \verb|\resultat| est ici possible puisque les séquences de contrôle qu'elle contient sont définies.\medskip
\subsection{Développement contrôlé, les macros {\ttfamily\textbackslash StrExpand} et {\ttfamily\textbackslash scancs}}
\label{scancs}
-La macro \verbinline|\StrExpand| développe les tokens de la chaîne passée en argument. Voici sa syntaxe :\par\nobreak\medskip
-\verbinline|\StrExpand|\arguC{nombre}\ARGU{chaine}\ARGU{nom}\smallskip
+La macro \verb|\StrExpand| développe les tokens de la chaîne passée en argument. Voici sa syntaxe :\par\nobreak\medskip
+\verb|\StrExpand|\arguC{nombre}\ARGU{chaine}\ARGU{nom}\smallskip
Le \argu{nombre} vaut 1 par défaut et représente le nombre de développement(s) que doit subir la \argu{chaine} de tokens. Le \argu{nom} est le nom d'une séquence de contrôle à laquelle est assigné le résultat, une fois que tous les tokens aient été développé le nombre de fois demandé.\medskip
La macro opère séquentiellement et par passe : chaque token est remplacé par son 1-dévelopement, et le token suivant subit le même traitement jusqu'à ce que la chaîne ait été parcourue. Ensuite, s'il reste des niveaux de développement à faire, une nouvelle passe est initiée, et ainsi de suite jusqu'à ce que le nombre de développements voulu aient été exécutés.\medskip
Voici un exemple :\par\nobreak\smallskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\def\csA{1 2}
+\showcode+\def\csA{1 2}
\def\csB{a \csA}
\def\csC{\csB\space}
\def\csD{x{\csA y}\csB{\csC z}}
-D\'eveloppement de \string\csD\ au\par
+Développement de \string\csD\ au\par
\StrExpand[0]{\csD}{\csE} niveau 0 :
\detokenize\expandafter{\csE}\par
\StrExpand[1]{\csD}{\csE} niveau 1 :
@@ -1665,68 +1116,44 @@ D\'eveloppement de \string\csD\ au\par
\StrExpand[3]{\csD}{\csE} niveau 3 :
\detokenize\expandafter{\csE}\par
\StrExpand[4]{\csD}{\csE} niveau 4 :
-\detokenize\expandafter{\csE}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \def\csA{1 2}
- \def\csB{a \csA}
- \def\csC{\csB\space}
- \def\csD{x{\csA y}\csB{\csC z}}
- Développement de \string\csD\ au\par
- \StrExpand[0]{\csD}{\csE} niveau 0 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[1]{\csD}{\csE} niveau 1 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[2]{\csD}{\csE} niveau 2 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[3]{\csD}{\csE} niveau 3 :
- \detokenize\expandafter{\csE}\par
- \StrExpand[4]{\csD}{\csE} niveau 4 :
- \detokenize\expandafter{\csE}
-\end{minipage}%
+\detokenize\expandafter{\csE}+
\medskip
-La macro agit séquentiellement et chaque token est développé isolément sans tenir compte de ce qui suit. On ne peut donc développer que des tokens qui se suffisent à eux même et dont le développement ne nécessite aucun autre token. Ainsi, \og\hbox{\verbinline|\iftrue A\else B\fi|}\fg, bien que se développant en \guill{A} ne peut être mis dans l'argument de \verbinline|\StrExpand|, et l'instruction :\par\nobreak\smallskip
-\hfil\verbinline|\StrExpand{\iftrue A\else B\fi}\resultat|\hfil{}\par\nobreak\smallskip
-fera échouer la compilation puisque le premier token \og\verbinline|\iftrue|\fg{} sera développé \emph{seul}, c'est-à-dire sans son \verbinline-\fi- correspondant, ce qui fâchera \TeX{} !\smallskip
+La macro agit séquentiellement et chaque token est développé isolément sans tenir compte de ce qui suit. On ne peut donc développer que des tokens qui se suffisent à eux même et dont le développement ne nécessite aucun autre token. Ainsi, \og\hbox{\verb|\iftrue A\else B\fi|}\fg, bien que se développant en \guill{A} ne peut être mis dans l'argument de \verb|\StrExpand|, et l'instruction :\par\nobreak\smallskip
+\hfil\verb|\StrExpand{\iftrue A\else B\fi}\resultat|\hfil{}\par\nobreak\smallskip
+fera échouer la compilation puisque le premier token \og\verb|\iftrue|\fg{} sera développé \emph{seul}, c'est-à-dire sans son \verb-\fi- correspondant, ce qui fâchera \TeX{} !\smallskip
-Les règles habituelles de lecture des arguments sont en vigueur, à savoir qu'un espace suivant une séquence de contrôle est ignoré, et plusieurs espaces consécutifs n'en font qu'un. Ces règles ne s'appliquent pas pour des espaces explicitement demandés avec \verb-\space- ou \verb*-\ -\footnote{À ce propos, \texttt{\string\space} n'a pas la même signification que \texttt{\string\ }. La première séquence de contrôle se \emph{développe} en un espace tandis que la deuxième est une primitive \TeX{} qui \emph{affiche} une espace. Comme toutes les primitives, cette dernière est son propre développement.}.\smallskip
+Les règles habituelles de lecture des arguments sont en vigueur, à savoir qu'un espace suivant une séquence de contrôle est ignoré, et plusieurs espaces consécutifs n'en font qu'un. Ces règles ne s'appliquent pas pour des espaces explicitement demandés avec \verb-\space- ou \verb*-\ -\footnote{À ce propos, \texttt{\string\space} n'a pas la même signification que \texttt{\string\ }. La première séquence de contrôle se \emph{développe} en un espace tandis que la deuxième est une primitive \TeX{} qui \emph{affiche} une espace. Comme toutes les primitives, cette dernière est son propre développement.}.\bigskip
-Le développement de ce qui se trouve à l'intérieur des groupes est \emph{indépendant} du mode d'exploration des groupes : cette macro possède ses propres commandes pour développer ce qui est dans les groupes ou pas. Par défaut, les tokens se trouvant à l'intérieur des groupes sont développés, mais on peut demander à ce que ce développement ne se fasse pas en invoquant \verbinline-\noexpandingroups- et revenir au comportement par defaut par \verbinline-\expandingroups-.\bigskip
+On peut détokeniser le résultat obtenu par la macro \verb-\StrExpand- avec la macro \verb-\scancs- dont la syntaxe est :\par\nobreak\medskip
+\verb|\scancs|\arguC{nombre}\ARGU{nom}\ARGU{chaine}\par\nobreak\smallskip
-On peut détokeniser le résultat obtenu par la macro \verbinline-\StrExpand- avec la macro \verbinline-\scancs- dont la syntaxe est :\par\nobreak\medskip
-\verbinline|\scancs|\arguC{nombre}\ARGU{nom}\ARGU{chaine}\par\nobreak\smallskip
Le \argu{nombre} vaut 1 par défaut et représente le nombre de développement(s) que doit subir chaque token constituant la \argu{chaine}. Le \argu{nom} est le nom d'une séquence de contrôle à laquelle est assigné le résultat, une fois que tous les tokens aient été développés le nombre de fois demandé et ensuite détokénisés.\smallskip
-\verbinline-\scancs- a été conservée pour garder une compatibilité avec des précédentes versions de \Xstring. Pour les mêmes raisons, sa syntaxe n'est pas cohérente avec la syntaxe des autres macros. Cette macro, devenue triviale, prend le résultat de \verbinline|\StrExpand| et lui applique simplement un \verbinline|\detokenize|.
+\verb-\scancs- a été conservée pour garder une compatibilité avec des précédentes versions de \Xstring. Pour les mêmes raisons, sa syntaxe n'est pas cohérente avec la syntaxe des autres macros. Cette macro, devenue triviale, prend le résultat de \verb|\StrExpand| et lui applique simplement un \verb|\detokenize|.
\subsection{À l'intérieur d'une définition de macro}
Avec le verbatim, certaines difficultés surviennent lorsque l'on se trouve à l'intérieur de la définition d'une macro, c'est-à-dire entre les accolades suivant un \verb|\def\macro| ou un \verb|\newcommand\macro|.\medskip
-Pour les mêmes raison qu'il est interdit d'employer la commande \verb|\verb| à l'intérieur de la définition d'une macro, les arguments verb du type |\argu{caractères}| sont également interdits, ce qui disqualifie la macro \verbinline|\verbtocs|. Il faut donc observer la règle suivante :\par\medskip
-\hfill{\bfseries Ne pas utiliser la macro \verbinline-\verbtocs- à l'intérieur de la définition d'une macro}.\hfill{}\bigskip
+Pour les mêmes raison qu'il est interdit d'employer la commande \verb|\verb| à l'intérieur de la définition d'une macro, les arguments verb du type |\argu{caractères}| sont également interdits, ce qui disqualifie la macro \verb|\verbtocs|. Il faut donc observer la règle suivante :\par\medskip
+\hfill{\bfseries Ne pas utiliser la macro \verb-\verbtocs- à l'intérieur de la définition d'une macro}.\hfill{}\bigskip
Mais alors, comment faire pour manipuler des arguments textuels verb et \guill{verbatimiser} dans les définitions de macro ?\bigskip
Il y a la primitive \verb|\detokenize| de $\varepsilon$-\TeX, mais elle comporte des restrictions, entre autres :
-
-\nobreak
\begin{itemize}
\item les accolades doivent être équilibrées;
\item les espaces consécutifs sont ignorés;
\item les signes \verb|%| sont interdits;
- \item une espace est ajoutée après chaque séquence de contrôle.
+ \item une espace est ajoutée après chaque séquence de contrôle;
+ \item le token \verb|#| devient \verb|##|.
\end{itemize}
\medskip
-Il est préférable d'utiliser la macro \verbinline|\scancs|, et définir avec \verbinline|\verbtocs| à l'extérieur des définitions de macros, des séquences de contrôle contenant des caractères spéciaux détokénisés. On pourra aussi utiliser la macro \verbinline|\tokenize| pour transformer le résultat final (qui est une chaîne de caractères) en une séquence de contrôle. On peut voir des exemples utilisant ces macros page~\pageref{exemples}, à la fin de ce manuel.\medskip
+Il est préférable d'utiliser la macro \verb|\scancs|, et définir avec \verb|\verbtocs| à l'extérieur des définitions de macros, des séquences de contrôle contenant des caractères spéciaux détokénisés. On pourra aussi utiliser la macro \verb|\tokenize| pour transformer le résultat final (qui est une chaîne de caractères) en une séquence de contrôle.\medskip
Dans l'exemple artificiel\footnote{On peut agir beaucoup plus simplement en utilisant la commande \texttt{\string\detokenize}. Il suffit de définir la macro ainsi :\par\texttt{\string\newcommand\string\bracearg[1]\{\string\detokenize\{\{\#1\}\}\}}} qui suit, on écrit une macro qui met son argument entre accolades. Pour cela, on définit en dehors de la définition de la macro 2 séquences de contrôles \verb|\Ob| et \verb|\Cb| contenant une accolade ouvrante et une accolade fermante de catcodes 12. Ces séquences de contrôle sont ensuite développées et utilisées à l'intérieur de la macro pour obtenir le résultat voulu :\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\verbtocs{\Ob}|{|
+\showcode+\verbtocs{\Ob}|{|
\verbtocs{\Cb}|}|
\newcommand\bracearg[1]{%
\def\text{#1}%
@@ -1734,302 +1161,29 @@ Dans l'exemple artificiel\footnote{On peut agir beaucoup plus simplement en util
\result}
\bracearg{xstring}\par
-\bracearg{\a}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\Ob}|{|
- \verbtocs{\Cb}|}|
- \newcommand\bracearg[1]{%
- \def\text{#1}%
- \scancs{\result}{\Ob\text\Cb}%
- \result}
-
- \bracearg{xstring}\par
- \bracearg{\a}
-\end{minipage}%
+\bracearg{\a}+
\subsection{La macro \ttfamily\textbackslash StrRemoveBraces}
Pour des utilisations spéciales, on peut désirer retirer les accolades délimitant les groupes dans un argument.
-On peut utiliser la macro \verbinline|\StrRemoveBraces| dont voici la syntaxe :\par\nobreak\smallskip
-\verbinline|\StrRemoveBraces|\ARGU{chaine}\arguC{nom}
+On peut utiliser la macro \verb|\StrRemoveBraces| dont voici la syntaxe :\par\nobreak\smallskip
+
+\verb|\StrRemoveBraces|\ARGU{chaine}\arguC{nom}
\smallskip
-Cette macro est sensible au mode d'exploration, et retirera \emph{toutes} les accolades avec \verbinline|\exploregroups| alors qu'elle ne retirera que les accolades des groupes de plus bas niveau avec \verbinline|\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
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexploregroups
+\showcode+\noexploregroups
\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
\meaning\mycs
\exploregroups
\StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
-\meaning\mycs
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexploregroups
- \StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
- \meaning\mycs
-
- \exploregroups
- \StrRemoveBraces{a{b{c}d}e{f}g}[\mycs]
- \meaning\mycs
-\end{minipage}%
-
-\subsection{Exemples d'utilisation en programmation}
-\label{exemples}
-Voici quelques exemples très simples d'utilisation des macros comme on pourrait en rencontrer en programmation.
-
-\subsubsection{Exemple 1}
-On cherche à remplacer les deux premiers \verb|\textit| par \verb|\textbf| dans la séquence de contrôle \verb|\myCS| qui contient :\par\nobreak\smallskip
-\hfill\verb|\textit{A}\textit{B}\textit{C}|\hfill{}
-\medskip
-
-On cherche évidemment à obtenir \verb|\textbf{A}\textbf{B}\textit{C}| qui affiche : \textbf{A}\textbf{B}\textit{C}\medskip
-
-Pour cela, on va développer les arguments des macros une fois avant qu'elles les traitent, en invoquant la commande \verbinline|\expandarg|.
-
-Ensuite, on définit \verb|\pattern| qui est le motif à remplacer, et \verb|\replace| qui est le motif de substitution. On travaille token par token puisque \verbinline|\expandarg| a été appelé, il suffit d'invoquer \verbinline|\StrSubstitute| pour faire les 2 substitutions.\medskip
-
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\expandarg
-\def\myCS{\textit{A}\textit{B}\textit{C}}
-\def\pattern{\textit}
-\def\replace{\textbf}
-\StrSubstitute[2]{\myCS}{\pattern}{\replace}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \expandarg
- \def\myCS{\textit{A}\textit{B}\textit{C}}
- \def\pattern{\textit}
- \def\replace{\textbf}
- \StrSubstitute[2]{\myCS}{\pattern}{\replace}
-\end{minipage}%
-\medskip
-
-Pour éviter de définir les séquences de contrôle \verb|\pattern| et \verb|\replace|, on aurait pu utiliser un leurre comme par exemple une séquence de contrôle qui se développe en \guill{rien} comme \verb|\empty|, et coder de cette façon :\par\smallskip
-\hfil\verbinline|\StrSubstitute[2]{\myCS}{\empty\textit}{\empty\textbf}|\hfil{}\medskip
-
-Ainsi, \verb|\empty| est développée en \guill{rien} et il reste dans les 2 derniers arguments les séquences de contrôles significatives \verb|\textit| et \verb|textbf|.\smallskip
-
-La séquence de contrôle \verbinline|\empty| est donc un \guill{hack} pour \verbinline|\expandarg| : elle permet de bloquer le développement du 1\ier{} token ! On aurait d'ailleurs pu utiliser \verbinline|\noexpand| au lieu de \verbinline|\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 :\par\nobreak\smallskip
-\hfil\verb|\StringDel{chaine}{position}{n}{\nom_resultat}|\hfil{}
-\medskip
-
-On peut procéder ainsi : sauvegarder la chaîne se trouvant juste avant la position. Ensuite enlever \verb|n + position| \USs à la chaîne initiale, et concaténer ce résultat à ce qui a été sauvegardé auparavant. Cela donne le code suivant :\par\nobreak\medskip
-
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\newcommand\StringDel[4]{%
- \begingroup
- \expandarg% portee locale au groupe
- \StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
- \StrGobbleLeft{\empty#1}{\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{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \newcommand\StringDel[4]{%
- \begingroup
- \expandarg% portée locale au groupe
- \StrLeft{\empty#1}{\number\numexpr#2-1}[#4]%
- \StrGobbleLeft{\empty#1}{\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 ces laborieux \guill{ponts} d'\verbinline|\expandafter|. Il suffit alors de remplacer l'assignation et la sortie du groupe se trouvant entre les lignes 6 à 10 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}} :\par\nobreak\smallskip
-\hfil\verbinline|\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 \verbinline|\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|\num| et \verb|\den| et simplement appeler la macro \TeX{} \verb|\frac| :\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\noexpandarg
-\newcommand\tofrac[1]{%
- \StrBefore{#1}{/}[\num]%
- \StrBehind{#1}{/}[\den]%
- $\frac{\num}{\den}$%
-}
-\tofrac{15/9}
-\tofrac{u_{n+1}/u_n}
-\tofrac{a^m/a^n}
-\tofrac{x+\sqrt{x}/\sqrt{x^2+x+1}}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \noexpandarg
- \newcommand\tofrac[1]{%
- \StrBefore{#1}{/}[\num]%
- \StrBehind{#1}{/}[\den]%
- $\frac{\num}{\den}$%
- }
- \tofrac{15/9}
- \tofrac{u_{n+1}/u_n}
- \tofrac{a^m/a^n}
- \tofrac{x+\sqrt{x}/\sqrt{x^2+x+1}}
-\end{minipage}%
-
-\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 \verbinline|\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 à \verbinline|\StrBehind|. Remarquons aussi que \verbinline|\expandarg| a été appelé et donc, le premier token 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}[c]{0.65\linewidth}
-\begin{lstlisting}
-\newcommand\grasapres[2]{%
- \noexpandarg
- \StrBehind[1]{#1 }{ #2 }[\mot]%
- \expandarg
- \StrBefore{\mot}{ }[\mot]%
- \StrSubstitute[1]{#1}{\mot}{\textbf{\mot}}%
-}
-
-\grasapres{Le package xstring est nouveau}{package}
-
-\grasapres{Le package xstring est nouveau}{ckage}
-
-\grasapres{Le package xstring est nouveau}{est}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \newcommand\grasapres[2]{%
- \noexpandarg
- \StrBehind[1]{#1 }{ #2 }[\mot]%
- \expandarg
- \StrBefore{\mot}{ }[\mot]%
- \StrSubstitute[1]{#1}{\mot}{\textbf{\mot}}%
- }
-
- \grasapres{Le package xstring est nouveau}{package}
-
- \grasapres{Le package xstring est nouveau}{ckage}
-
- \grasapres{Le package xstring est nouveau}{est}
-\end{minipage}%
-\fullexpandarg
-
-\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 \verbinline|\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 \verbinline|\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
-
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\verbtocs{\antislash}|\|
-\newcommand\swaptwofirst[1]{%
- \begingroup
- \fullexpandarg
- \scancs[0]\chaine{#1}%
- \StrBefore[3]{\chaine}{\antislash}[\firsttwo]%
- \StrBehind{\chaine}{\firsttwo}[\others]
- \StrBefore[2]{\firsttwo}{\antislash}[\avant]
- \StrBehind{\firsttwo}{\avant}[\apres]%
- \tokenize\myCS{\apres\avant\others}%
- \myCS
- \endgroup
-}
-
-\swaptwofirst{\underline{A}\textbf{B}\textit{C}}
-
-\swaptwofirst{\Large\underline{A}\textbf{B}123}
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \verbtocs{\antislash}|\|
- \newcommand\swaptwofirst[1]{%
- \begingroup
- \fullexpandarg
- \scancs[0]\chaine{#1}%
- \StrBefore[3]{\chaine}{\antislash}[\firsttwo]%
- \StrBehind{\chaine}{\firsttwo}[\others]
- \StrBefore[2]{\firsttwo}{\antislash}[\avant]
- \StrBehind{\firsttwo}{\avant}[\apres]%
- \tokenize\myCS{\apres\avant\others}%
- \myCS
- \endgroup
- }
-
- \swaptwofirst{\underline{A}\textbf{B}\textit{C}}
-
- \swaptwofirst{\Large\underline{A}\textbf{B}123}
-\end{minipage}%
-
-\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 \verbinline|\StrBetween| et \verb|\numexpr| de façon astucieuse, et profite du fait que \verbinline-\StrBetween- n'explore pas les groupes :\par\nobreak\medskip
-\begin{minipage}[c]{0.65\linewidth}
-\begin{lstlisting}
-\newcommand\findword[3][ ]{%
- \StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}%
-}
-\noexpandarg
-|\findword{a bc d\textbf{e f} gh}{3}|
-
-|\findword[\nil]{1 \nil 2 3 \nil4\nil5}{2}|
-\end{lstlisting}%
-\end{minipage}\hfill
-\begin{minipage}[c]{0.35\linewidth}
- \styleexercice
- \newcommand\findword[3][ ]{%
- \StrBetween[#3,\numexpr#3+1]{#1#2#1}{#1}{#1}%
- }
- \noexpandarg
- |\findword{a bc d\textbf{e f} gh}{3}|
-
- |\findword[\nil]{1 \nil 2 3 \nil4\nil5}{2}|
-\end{minipage}%
-
-On peut observer que le résultat de la ligne 7 qui est \og\verb*|2 3 |\fg{} ne commence \emph{pas} par une espace puisque dans le code, cet espace suit une séquence de contrôle~---~ici \verb|\nil|.
-\bigskip\bigskip
+\meaning\mycs+
\begin{center}
$\star$\par
$\star$\quad$\star$
\end{center}
-\bigskip\bigskip
C'est tout, j'espère que ce package vous sera utile !\par\nobreak
Merci de me signaler par \href{mailto:unbonpetit@netc.fr}{email} tout bug ou toute proposition d'amélioration\ldots\par\nobreak\bigskip
diff --git a/macros/generic/xstring/xstring.tex b/macros/generic/xstring/xstring.tex
index 920a76933c..3a746ba30b 100644
--- a/macros/generic/xstring/xstring.tex
+++ b/macros/generic/xstring/xstring.tex
@@ -4,9 +4,9 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
\def\xstringname {xstring} %
-\def\xstringversion {1.85} %
+\def\xstringversion {1.86} %
% %
-\def\xstringdate {2023/01/14} %
+\def\xstringdate {2023/08/22} %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
@@ -29,12 +29,12 @@
\ifdefined\usepackage\else
\immediate\write-1 {Package: xstring \xstringdate\space v\xstringversion\space String manipulations (CT)}%
\fi
-\newcount\integerpart
-\newcount\decimalpart% compteurs utilisés par xstring
\edef\restorexstringcatcode{\catcode\number`\_ =\number\catcode`\_\relax}
\catcode`\_=11
+\newcount\xs_counta
+\newcount\xs_countb% compteurs utilisés par xstring
\long\def\xs_execfirst#1#2{#1}
\long\def\xs_execsecond#1#2{#2}
\long\def\xs_gobarg#1{}
@@ -64,7 +64,9 @@
\long\def\xs_gobtobrace#1#{}
\long\def\xs_ifx#1{\ifx#1\expandafter\xs_execfirst\else\expandafter\xs_execsecond\fi}
\def\xs_ifnum#1{\ifnum#1\expandafter\xs_execfirst\else\expandafter\xs_execsecond\fi}
-\long\def\xs_ifempty#1{\expandafter\xs_ifx\expandafter{\expandafter\relax\detokenize{#1}\relax}}
+\long\def\xs_ifemptyarg#1{\expandafter\xs_ifx\expandafter{\expandafter\relax\detokenize{#1}\relax}}
+\long\def\xs_ifemptymacro#1{\xs_ifx{#1\empty}}
+\let\xs_ifempty\xs_ifemptyarg
\def\xs_toks_toverb{% lit 1 argument et le transforme en verb
\begingroup
@@ -75,7 +77,7 @@
}
\def\setverbdelim#1{% définit quel est le délimiteur de verb
- \xs_exparg\xs_ifempty{\xs_gobarg#1}%
+ \xs_exparg\xs_ifemptyarg{\xs_gobarg#1}%
{}
{\errmessage{Package xstring Warning: verb delimiter "\detokenize{#1}" is not a single token}}%
\def\xs_read_verb##1#1##2#1{\endgroup\xs_assign_verb{##2}}% on appelle l'exécution de fin
@@ -103,7 +105,7 @@
\expandafter\xs_assigntokenizeresult\scantokens\expandafter{\expandafter\relax\xs_reserved_A}% on fait l'assignation
}%
-\long\def\xs_assign_xstringresult#1#2{\xs_ifempty{#2}{#1}{\def#2{#1}}}
+\long\def\xs_assign_xstringresult#1#2{\xs_ifemptyarg{#2}{#1}{\def#2{#1}}}
\def\xs_ldef{\long\def}
\def\xs_ledef{\long\edef}
@@ -145,10 +147,10 @@
% Cette macro interne prend la 1ere unité syntaxique de #1 et assigne le résultat à #2
\long\def\xs_returnfirstsyntaxunit#1#2{%
\let\xs_toks\relax
- \xs_ifempty{#1}
+ \xs_ifemptyarg{#1}
{\let#2\empty
}
- {\xs_eearg\xs_ifempty{\expandafter\xs_beforespace\detokenize{#1} \_nil}% #1 commence par un espace ?
+ {\xs_eearg\xs_ifemptyarg{\expandafter\xs_beforespace\detokenize{#1} \_nil}% #1 commence par un espace ?
{\def#2{ }}
{\xs_ifbeginwithbrace{#1}
{\def\xs_groupfound{\xs_exparg{\def#2}{\expandafter{#2}}\xs_gobtonil}% on met #2 dans des accolades et on finit
@@ -165,10 +167,10 @@
}
\long\def\xs_removefirstsyntaxunit#1#2{%
- \xs_ifempty{#1}
+ \xs_ifemptyarg{#1}
{\let#2\empty
}
- {\xs_eearg\xs_ifempty{\expandafter\xs_beforespace\detokenize{#1} \_nil}% #1 commence par un espace ?
+ {\xs_eearg\xs_ifemptyarg{\expandafter\xs_beforespace\detokenize{#1} \_nil}% #1 commence par un espace ?
{\xs_exparg\xs_ifbeginwithbrace{\xs_gobspace#1}
{\xs_exparg{\def#2}{\xs_gobtobrace#1}}%
{\xs_exparg{\def#2}{\xs_afterspace#1\_nil}}%
@@ -211,7 +213,7 @@
\xs_exparg\xs_assign_one_arg{\number\numexpr##1+#1-1}%
\edef\xs_reserved_B{\noexpand\xs_expand\csname xs_arg_\romannumeral\numexpr##1\endcsname}%
\xs_ifnum{##1=1 }% si c'est le premier argument
- {\xs_ifempty{#3}%
+ {\xs_ifemptyarg{#3}%
{\xs_eaddtomacro\xs_newargs{\expandafter{\xs_reserved_B}}%
\edef\xs_reserved_B{\ifnum##1>#4 xs_def\else xs_assign\fi}%
}% et s'il y a un argument optionnel alors, on met des crochets
@@ -301,7 +303,7 @@
% \xs_atbegingroup (un groupe vient d'être ouvert)
% \xs_atnextsyntaxunit (la future US n'est pas un groupe)
\def\xs_read_reserved_C{%
- \xs_exparg\xs_ifempty{\xs_reserved_C}%
+ \xs_ifemptymacro\xs_reserved_C
{\xs_ifnum{\xs_nestlevel=0 }
{}
{\xs_atendofgroup
@@ -312,15 +314,15 @@
\xs_exparg\xs_removefirstsyntaxunit{\xs_reserved_C}\xs_reserved_C
\xs_exploregroups
\xs_ifx{\bgroup\xs_toks}
- {\advance\integerpart1
+ {\advance\xs_counta1
\begingroup
\expandafter\def\expandafter\xs_reserved_C\xs_reserved_A
\xs_calc_grouIP
\def\xs_nestlevel{1}%
- \integerpart0
+ \xs_counta0
\xs_atbegingroup
}
- {\advance\decimalpart1
+ {\advance\xs_countb1
\xs_atnextsyntaxunit
}%
\xs_read_reserved_C
@@ -331,12 +333,12 @@
% 1 sous-routine est appelée :
% \xs_atoccurfound (une occurrence a été trouvée)
\def\xs_read_reserved_D{%
- \xs_exparg\xs_ifempty{\xs_reserved_D}%
+ \xs_ifemptymacro\xs_reserved_D
{\xs_ifnum{\xs_nestlevel=0 }
{}
{\edef\__temp{%
\endgroup
- \noexpand\decimalpart=\number\decimalpart\relax
+ \noexpand\xs_countb=\number\xs_countb\relax
\unexpanded{\xs_addtomacro\xs_reserved_C}{{\unexpanded\expandafter{\xs_reserved_C}}}%
}%
\__temp
@@ -344,7 +346,7 @@
}%
}%
{\xs_exptwoargs\xs_IfBeginWith_i\xs_reserved_D\xs_reserved_E
- {\advance\decimalpart1
+ {\advance\xs_countb1
\let\xs_reserved_D\xs_reserved_A
\xs_atoccurfound
}%
@@ -352,13 +354,13 @@
\xs_exparg\xs_removefirstsyntaxunit{\xs_reserved_D}\xs_reserved_D
\xs_exploregroups
\xs_ifx{\bgroup\xs_toks}
- {\advance\integerpart1
+ {\advance\xs_counta1
\begingroup
\expandafter\def\expandafter\xs_reserved_D\xs_reserved_A
\xs_calc_grouIP
\let\xs_reserved_C\empty
\def\xs_nestlevel{1}%
- \integerpart0
+ \xs_counta0
}
{\xs_eaddtomacro\xs_reserved_C{\xs_reserved_A}%
}%
@@ -376,7 +378,7 @@
}
\def\xs_StrRemoveBraces_i{%
- \xs_exparg\xs_ifempty{\xs_reserved_C}%
+ \xs_ifemptymacro\xs_reserved_C
{\xs_ifnum{\xs_nestlevel=0 }
{}
{\xs_endgroup_eaddtomacro\xs_reserved_B\xs_reserved_B
@@ -414,13 +416,13 @@
\long\def\xs_cutafteroccur_i#1#2#3{%
\def\xs_reserved_D{#1}\let\xs_reserved_C\empty\def\xs_reserved_E{#2}%
- \decimalpart0 \integerpart0 \gdef\groupID{0}\def\xs_nestlevel{0}%
+ \xs_countb0 \xs_counta0 \gdef\groupID{0}\def\xs_nestlevel{0}%
\def\xs_atoccurfound{%
- \xs_ifnum{\decimalpart=\numexpr(#3)\relax}
+ \xs_ifnum{\xs_countb=\numexpr(#3)\relax}
{\edef\__temp{%
\def\noexpand\xs_reserved_C{\unexpanded\expandafter{\xs_reserved_C}}%
\def\noexpand\xs_reserved_D{\unexpanded\expandafter{\xs_reserved_D}}%
- \noexpand\decimalpart=\number\decimalpart\relax
+ \noexpand\xs_countb=\number\xs_countb\relax
}%
\expandafter\xs_exitallgroups\__temp
\xs_gobarg% mange l'appel récursif \xs_read_reserved_D dans \xs_read_reserved_D
@@ -429,7 +431,7 @@
}%
}%
\xs_read_reserved_D
- \xs_ifnum{\decimalpart=\numexpr(#3)\relax}% occurrence trouvée ?
+ \xs_ifnum{\xs_countb=\numexpr(#3)\relax}% occurrence trouvée ?
{\let\xs_reserved_E\xs_reserved_D
\xs_exparg{\def\xs_reserved_D}{\xs_reserved_C#2}%
}
@@ -441,20 +443,20 @@
\xs_newmacro*3\IfSubStr{1}{2}{0}{%
\xs_cutafteroccur{#2}{#3}{#1}%
- \xs_exparg\xs_ifempty{\xs_reserved_D}\xs_execsecond\xs_execfirst
+ \expandafter\expandafter\expandafter\unless\xs_ifemptymacro\xs_reserved_D
}
\xs_newmacro*2\IfBeginWith{}{2}{0}{%
- \xs_ifempty{#2}%
+ \xs_ifemptyarg{#2}%
{\xs_execsecond}
{\xs_IfBeginWith_i{#1}{#2}}%
}
\long\def\xs_IfBeginWith_i#1#2{%
- \xs_ifempty{#2}%
+ \xs_ifemptyarg{#2}%
{\xs_execfirst% #2 est vide, tous les tests sont passés avec succès : on renvoie #3
}
- {\xs_ifempty{#1}%
+ {\xs_ifemptyarg{#1}%
{\xs_execsecond% #1 est vide, c'est que #2 est + long que #1 : on renvoie #4
}
{\xs_returnfirstsyntaxunit{#2}\xs_reserved_B
@@ -471,13 +473,13 @@
}
\xs_newmacro*2\IfEndWith{}{2}{0}{%
- \xs_ifempty{#2}%
+ \xs_ifemptyarg{#2}%
{\xs_execsecond
}
{\xs_StrCount{#1}{#2}[\xs_reserved_A]%
\xs_ifnum{\xs_reserved_A=0 }
{\xs_execsecond}
- {\xs_exparg\xs_ifempty{\xs_reserved_C}}%
+ {\xs_ifemptymacro\xs_reserved_C}%
}%
}
@@ -495,90 +497,160 @@
\xs_exparg\xs_cutafteroccur\xs_reserved_C{#5}{#2}%
\xs_exparg\xs_cutafteroccur\xs_reserved_C{#4}{#1}%
\gdef\groupID{}%
- \xs_exparg\xs_ifempty{\xs_reserved_C}%
- \xs_execsecond
- \xs_execfirst
+ \expandafter\expandafter\expandafter\unless\xs_ifemptymacro\xs_reserved_D% bugfix 1.86, c'est \xs_reserved_D et non pas \xs_reserved_C !
}
\xs_newmacro*4\IfSubStrBehind{1,1}{3}{0}{\xs_IfSubStrBehind_i[#1]{#2}{#3}{#4}}
\long\def\xs_IfSubStrBehind_i[#1,#2]#3#4#5{\xs_IfSubStrBefore_i[#2,#1]{#3}{#5}{#4}}
-\long\def\xs_formatnumber#1#2{%
- \xs_ifempty{#1}%
- {\def#2{0X}% si vide, renvoie 0X
+\def\xs_errnumber{X}
+\def\xs_testifzero#1{% teste si #1 est constitué de 0
+ \xs_testifzero_a#1\relax
+}
+\def\xs_testifzero_a#1{%
+ \xs_ifx{\relax#1}
+ {%
+ \def\remain_part{0}%
+ \xs_execfirst
}
- {\xs_returnfirstsyntaxunit{#1}\xs_reserved_A
- \def\xs_reserved_B{+}%
- \xs_ifx{\xs_reserved_A\xs_reserved_B}
- {\xs_removefirstsyntaxunit{#1}\xs_reserved_C
- \xs_exparg\xs_ifempty{\xs_reserved_C}%
- {\def#2{+0X}}
- {\xs_exparg{\def#2}{\expandafter+\expandafter0\xs_reserved_C}}%
+ {%
+ \xs_ifx{0#1}
+ {%
+ \xs_testifzero_a
}
- {\def\xs_reserved_B{-}%
- \xs_ifx{\xs_reserved_A\xs_reserved_B}
- {\xs_removefirstsyntaxunit{#1}\xs_reserved_A
- \xs_exparg\xs_ifempty{\xs_reserved_A}%
- {\def#2{-0X}}%
- {\xs_exparg{\def#2}{\expandafter-\expandafter0\xs_reserved_A}}%
+ {%
+ \xs_testifzero_b#1%
+ }%
+ }%
+}
+\def\xs_testifzero_b#1\relax{%
+ \def\remain_part{#1}%
+ \xs_execsecond
+}
+\xs_newmacro\IfDecimal{}{1}{0}{%
+ \def\integerpart{0}\def\xs_intpartlen{0}%
+ \def\decimalpart{0}\def\xs_decpartlen{0}%
+ \let\xs_decimalsep\empty
+ \let\afterdecimal\empty
+ \expandafter\xs_parsesigns\expandafter{\expandafter}\detokenize\expandafter{\expanded{#1}}\relax
+}
+\def\xs_parsesigns#1#2{% #1= signes lus #2=caractère en cours
+ \xs_ifx{\relax#2}
+ {%
+ \let\afterdecimal\xs_errnumber
+ \xs_execsecond
+ }
+ {%
+ \xs_ifnum{\xs_ifx{+#2}10\xs_ifx{-#2}10>0 }
+ {%
+ \xs_parsesigns{#1#2}%
+ }
+ {%
+ \edef\xs_sgnpart{\ifnum#11=-1 -\fi}%
+ \let\integerpart\empty
+ \xs_parseintpart0#2%
+ }%
+ }%
+}
+\def\xs_parseintpart#1#2{% #1=nombre de caractères lus #2=caractère en cours
+ \xs_ifx{\relax#2}
+ {%
+ \def\xs_intpartlen{#1}%
+ \xs_ifnum{#1>0 }
+ {%
+ \edef\integerpart{\xs_sgnpart\integerpart}%
+ \xs_execfirst
+ }
+ {%
+ \let\afterdecimal\xs_errnumber
+ \xs_execsecond
+ }%
+ }
+ {%
+ \xs_ifdigit{#2}
+ {%
+ \edef\integerpart{\integerpart#2}%
+ \expandafter\xs_parseintpart\expandafter{\number\numexpr#1+1}%
+ }
+ {%
+ \def\xs_intpartlen{#1}%
+ \xs_ifnum{\xs_ifx{.#2}10\xs_ifx{,#2}10>0 }
+ {%
+ \def\xs_decimalsep{#2}%
+ \expandafter\xs_testifzero\expandafter{\integerpart}
+ {\def\integerpart{0}}
+ {\edef\integerpart{\xs_sgnpart\remain_part}}%
+ \let\decimalpart\empty
+ \xs_parsedecpart0%
}
- {\def#2{0#1}%
+ {%
+ \xs_gobtoendnumber#2%
}%
}%
}%
}
-
-\xs_newmacro\IfInteger{}{1}{0}{%
- \xs_formatnumber{#1}\xs_reserved_A
- \decimalpart0
- \afterassignment\xs_defafterinteger\integerpart\xs_reserved_A\relax\_nil
- \let\xs_after_intpart\afterinteger
- \expandafter\xs_testdot\afterinteger\_nil
- \xs_ifx{\empty\afterdecimal}
- {\xs_ifnum{\decimalpart=0 }
- {\xs_execfirst% partie décimale constituée de 0 --> seul cas où on renvoie vrai
+\def\xs_parsedecpart#1#2{% #1=nombre de caractères lus #2=caractère en cours
+ \xs_ifx{\relax#2}
+ {%
+ \def\xs_decpartlen{#1}%
+ \xs_ifnum{#1>0 }
+ {%
+ \expandafter\xs_testifzero\expandafter{\decimalpart}
+ {%
+ \def\decimalpart{0}%
+ }
+ {}%
+ \xs_execfirst
}
- {\expandafter\xs_defafterinteger\xs_after_intpart\relax\_nil
+ {%
+ \def\decimalpart{0}\def\xs_decpartlen{0}%
+ \let\afterdecimal\xs_errnumber
\xs_execsecond
}%
}
- {\expandafter\xs_defafterinteger\xs_after_intpart\relax\_nil
- \xs_execsecond
+ {%
+ \xs_ifdigit{#2}
+ {%
+ \edef\decimalpart{\decimalpart#2}%
+ \expandafter\xs_parsedecpart\expandafter{\number\numexpr#1+1}%
+ }
+ {%
+ \expandafter\xs_testifzero\expandafter{\decimalpart}
+ {%
+ \def\decimalpart{0}%
+ }
+ {}%
+ \xs_gobtoendnumber#2%
+ }%
}%
}
-
-\xs_newmacro\IfDecimal{}{1}{0}{%
- \xs_formatnumber{#1}\xs_reserved_A
- \decimalpart0
- \afterassignment\xs_defafterinteger\integerpart\xs_reserved_A\relax\_nil
- \expandafter\xs_testdot\afterinteger\_nil
- \xs_ifx{\empty\afterdecimal}
-}
-
-\begingroup\catcode`\@ 11
-\long\gdef\xs_defafterinteger#1\relax\_nil{\def\@xs@afterinteger{#1}\let\afterinteger\@xs@afterinteger}
-\long\gdef\xs_defafterdecimal#1\_nil{\def\@xs@afterdecimal{#1}\let\afterdecimal\@xs@afterinteger}
-\endgroup
-
-\def\xs_testdot{%
- \let\xs_decsep\empty
- \xs_ifnxttok.
- {\def\xs_decsep{.}\xs_readdecimalpart}%
- {\xs_testcomma}%
+\def\xs_gobtoendnumber#1\relax{\def\afterdecimal{#1}\xs_execsecond}
+\def\xs_ifdigit#1{%
+ \xs_ifnum{\ifnum`#1<`0 0\else1\fi \ifnum`#1>`9 0\else1\fi=11 }
}
-
-\def\xs_testcomma{%
- \xs_ifnxttok,
- {\def\xs_dessep{,}\xs_readdecimalpart}%
- {\xs_defafterdecimal}%
-}
-
-\long\def\xs_readdecimalpart#1#2\_nil{%
- \xs_ifempty{#2}
- {\def\xs_reserved_A{0X}}
- {\def\xs_reserved_A{0#2}}%
- \afterassignment\xs_defafterinteger\decimalpart\xs_reserved_A\relax\_nil
- \expandafter\xs_defafterdecimal\afterinteger\_nil
+\xs_newmacro\IfInteger{}{1}{0}{%
+ \IfDecimal{#1}
+ {%
+ \xs_ifnum{\decimalpart=0 }
+ {%
+ \let\afterinteger\empty
+ \xs_execfirst
+ }
+ {%
+ \edef\afterinteger{\xs_decimalsep\decimalpart}%
+ \xs_execsecond
+ }%
+ }
+ {%
+ \xs_ifnum{\xs_ifx{\xs_decimalsep\empty}01\xs_ifx{\afterdecimal\xs_errnumber}10=11 }
+ {%
+ \let\afterinteger\xs_decimalsep
+ }
+ {%
+ \edef\afterinteger{\xs_decimalsep\afterdecimal}%
+ }%
+ \xs_execsecond
+ }
}
% test d'égalité sur des chaines (et des chaines contenant des nombres)
@@ -631,7 +703,7 @@
\long\def\xs_testcase##1##2##3\_nil{% lit les 2 premieres unités syntaxiques dans ##1 et ##2. Les autres dans ##3
#1{#2}{##1}% compare
{\xs_testopt{\xs_IfStringCase_ii{##2}}{}}% le test est positif, on exécute le code correspondant et on mange l'argument optionnel ## BUGfix dans 1.82
- {\xs_ifempty{##3}%
+ {\xs_ifemptyarg{##3}%
{\xs_testopt{\xs_IfStringCase_i}{}}% s'il n'y a plus de cas, on exécute le code <autres cas> ## BUGfix dans 1.82
{\xs_testcase##3\_nil}% sinon, on recommence avec ce qui reste
}%
@@ -677,17 +749,17 @@
% par la chaine #4 dans la chaine #2
\xs_newmacro\StrSubstitute{0}{3}{1}{%
\def\xs_reserved_D{#2}\let\xs_reserved_C\empty\def\xs_reserved_E{#3}%
- \decimalpart0 \integerpart0 \gdef\groupID{0}\def\xs_nestlevel{0}%
+ \xs_countb0 \xs_counta0 \gdef\groupID{0}\def\xs_nestlevel{0}%
\def\xs_atoccurfound{%
\xs_ifnum{#1<1 }
{\def\xs_reserved_A{#4}}
- {\xs_ifnum{\decimalpart>#1 }
+ {\xs_ifnum{\xs_countb>#1 }
{\def\xs_reserved_A{#3}}
{\def\xs_reserved_A{#4}}%
}%
\xs_eaddtomacro\xs_reserved_C{\xs_reserved_A}%
}%
- \xs_ifempty{#3}%
+ \xs_ifemptyarg{#3}%
{\xs_exparg\xs_assign_xstringresult{\xs_reserved_D}{#5}%
}
{\xs_read_reserved_D
@@ -702,17 +774,17 @@
% Compte combien d'unités syntaxiques contient la chaine #1 ?
\xs_newmacro\StrLen{}{1}{1}{%
- \def\xs_reserved_C{#1}\decimalpart0 \def\xs_nestlevel{0}\gdef\groupID{0}%
+ \def\xs_reserved_C{#1}\xs_countb0 \def\xs_nestlevel{0}\gdef\groupID{0}%
\let\xs_atbegingroup\relax
- \def\xs_atendofgroup{\expandafter\endgroup\expandafter\decimalpart\number\decimalpart\relax}%
+ \def\xs_atendofgroup{\expandafter\endgroup\expandafter\xs_countb\number\xs_countb\relax}%
\let\xs_atnextsyntaxunit\relax
\xs_read_reserved_C
- \xs_exparg\xs_assign_xstringresult{\number\decimalpart}{#2}%
+ \xs_exparg\xs_assign_xstringresult{\number\xs_countb}{#2}%
}
% Macro interne fermant autant de groupes que nécessaire pour trouver une unité syntaxique derrière
\def\xs_continuetonext{%
- \xs_exparg\xs_ifempty{\xs_reserved_C}%
+ \xs_ifemptymacro\xs_reserved_C
{\ifnum\xs_nestlevel>0
\xs_endgroup_eaddtomacro\xs_reserved_B{\expandafter{\xs_reserved_B}}% on concatène
\expandafter\xs_continuetonext% on recommence
@@ -723,8 +795,8 @@
\def\xs_calc_grouIP{%
\begingroup\def\xs_reserved_A{0}%
\xs_ifx{\xs_reserved_A\groupID}% si on arrive du groupe de niveau 0
- {\endgroup\xdef\groupID{\number\integerpart}}% on met simplement le niveau
- {\endgroup\xs_eearg{\gdef\groupID}{\expandafter\groupID\expandafter,\number\integerpart}}%
+ {\endgroup\xdef\groupID{\number\xs_counta}}% on met simplement le niveau
+ {\endgroup\xs_eearg{\gdef\groupID}{\expandafter\groupID\expandafter,\number\xs_counta}}%
}
% Cette macro coupe la chaine #1 après l'unité syntaxique n°#2
@@ -741,11 +813,11 @@
\long\def\xs_StrSplit_ii#1#2{%
\let\xs_reserved_B\empty\def\xs_reserved_C{#2}\def\xs_reserved_D{#1}\gdef\groupID{}%
\ifnum#1>0
- \decimalpart0 \integerpart0 \gdef\groupID{0}\def\xs_nestlevel{0}%
+ \xs_countb0 \xs_counta0 \gdef\groupID{0}\def\xs_nestlevel{0}%
\def\xs_atendofgroup{%
\edef\__temp{%
\endgroup
- \noexpand\decimalpart=\number\decimalpart\relax
+ \noexpand\xs_countb=\number\xs_countb\relax
\unexpanded{\xs_addtomacro\xs_reserved_B}{{\unexpanded\expandafter{\xs_reserved_B}}}%
}%
\__temp
@@ -753,7 +825,7 @@
\def\xs_atbegingroup{\let\xs_reserved_B\empty}%
\def\xs_atnextsyntaxunit{%
\xs_eaddtomacro\xs_reserved_B{\xs_reserved_A}%
- \xs_ifnum{\decimalpart=\xs_reserved_D\relax}
+ \xs_ifnum{\xs_countb=\xs_reserved_D\relax}
{\ifx\xs_reserved_C\empty\xs_reserved_E\fi
\edef\__temp{\def\noexpand\xs_reserved_B{\unexpanded\expandafter{\xs_reserved_B}}\def\noexpand\xs_reserved_C{\unexpanded\expandafter{\xs_reserved_C}}}%
\expandafter\xs_exitallgroups\__temp
@@ -771,7 +843,7 @@
% \macroA reçoit ce qui se trouve avant la n ème occurrence <motif> dans <texte>
% \macroB reçoit ce qui est après cette n ème occurrence
\xs_newmacro*3\StrCut{1}{2}{0}{%
- \xs_ifempty{#3}%
+ \xs_ifemptyarg{#3}%
{\gdef\groupID{}\let\xs_reserved_C\empty\let\xs_reserved_E\empty
}
{\xs_ifnum{#1<1 }
@@ -783,13 +855,13 @@
\long\def\xs_StrCut_ii#1#2#3{%
\let\xs_reserved_C\empty\def\xs_reserved_D{#1}\def\xs_reserved_E{#2}%
- \decimalpart0 \integerpart0 \gdef\groupID{0}\def\xs_nestlevel{0}%
+ \xs_countb0 \xs_counta0 \gdef\groupID{0}\def\xs_nestlevel{0}%
\def\xs_atoccurfound{%
- \xs_ifnum{\decimalpart=\numexpr(#3)\relax}
+ \xs_ifnum{\xs_countb=\numexpr(#3)\relax}
{\edef\__temp{%
\def\noexpand\xs_reserved_C{\unexpanded\expandafter{\xs_reserved_C}}%
\def\noexpand\xs_reserved_D{\unexpanded\expandafter{\xs_reserved_D}}%
- \noexpand\decimalpart=\number\decimalpart\relax
+ \noexpand\xs_countb=\number\xs_countb\relax
}%
\expandafter\xs_exitallgroups\__temp
\xs_gobarg% stoppe la récursivité dans \xs_read_reserved_D
@@ -852,11 +924,11 @@
\xs_newmacro\StrChar{}{2}{1}{%
\let\xs_reserved_B\empty\def\xs_reserved_C{#1}\def\xs_reserved_D{#2}%
\ifnum#2>0
- \def\groupID{0}\def\xs_nestlevel{0}\integerpart0 \decimalpart0
+ \def\groupID{0}\def\xs_nestlevel{0}\xs_counta0 \xs_countb0
\let\xs_atbegingroup\relax
- \def\xs_atendofgroup{\expandafter\endgroup\expandafter\decimalpart\number\decimalpart\relax}%
+ \def\xs_atendofgroup{\expandafter\endgroup\expandafter\xs_countb\number\xs_countb\relax}%
\def\xs_atnextsyntaxunit{%
- \ifnum\decimalpart=\xs_reserved_D% la n ième US est atteinte ?
+ \ifnum\xs_countb=\xs_reserved_D% la n ième US est atteinte ?
\edef\__temp{\def\noexpand\xs_reserved_B{\unexpanded\expandafter{\xs_reserved_A}}}% on capture l'US en cours qui est celle cherchée
\expandafter\xs_exitallgroups\__temp
\expandafter\xs_gobarg% stoppe la récursivité dans \xs_read_reserved_C
@@ -864,7 +936,7 @@
}%
\xs_read_reserved_C
\fi
- \xs_exparg\xs_ifempty{\xs_reserved_B}%
+ \xs_ifemptymacro\xs_reserved_B
{\gdef\groupID{}}
{}%
\xs_exparg\xs_assign_xstringresult{\xs_reserved_B}{#3}%
@@ -873,13 +945,13 @@
% Combien de fois compte t-on #2 dans #1 ?
\xs_newmacro\StrCount{}{2}{1}{%
\def\xs_reserved_D{#1}\def\xs_reserved_E{#2}\let\xs_reserved_C\empty
- \xs_ifempty{#2}%
+ \xs_ifemptyarg{#2}%
{\xs_assign_xstringresult{0}{#3}%
}
- {\decimalpart0 \integerpart0 \gdef\groupID{0}\def\xs_nestlevel{0}%
+ {\xs_countb0 \xs_counta0 \gdef\groupID{0}\def\xs_nestlevel{0}%
\def\xs_atoccurfound{\let\xs_reserved_C\empty\xs_read_reserved_D}%
\xs_read_reserved_D
- \xs_exparg\xs_assign_xstringresult{\number\decimalpart}{#3}%
+ \xs_exparg\xs_assign_xstringresult{\number\xs_countb}{#3}%
}%
}
@@ -916,9 +988,9 @@
\long\def\xs_StrCompare_i#1#2#3{%
\def\xs_StrCompare_iii##1{%
\let\xs_reserved_A\empty
- \xs_exparg\xs_ifempty{\xs_reserved_C}%
+ \xs_ifemptymacro\xs_reserved_C
{\edef\xs_reserved_A{*\xs_comparecoeff}}%
- {\xs_exparg\xs_ifempty{\xs_reserved_D}%
+ {\xs_ifemptymacro\xs_reserved_D
{\edef\xs_reserved_A{*\xs_comparecoeff}}
{}%
}%
@@ -928,7 +1000,7 @@
\xs_exparg\xs_returnfirstsyntaxunit{\xs_reserved_C}\xs_reserved_A
\xs_exparg\xs_returnfirstsyntaxunit{\xs_reserved_D}\xs_reserved_B
\xs_ifx{\xs_reserved_B\xs_reserved_A}
- {\xs_exparg\xs_ifempty{\xs_reserved_A}%
+ {\xs_ifemptymacro\xs_reserved_A
{\xs_StrCompare_iii{##1}% les 2 unités syntaxiques sont égales, on renvoie la position
}
{\def\xs_next{\xs_exparg\xs_StrCompare_ii{\number\numexpr##1+1}}% les 2 unités syntaxiques sont égales et non vides, on recommence
@@ -953,13 +1025,13 @@
\long\def\xs_StrFindGroup_i#1#2[#3]{%
\def\xs_StrFindGroup_ii{%
- \xs_exparg\xs_ifempty{\xs_reserved_C}%
+ \xs_ifemptymacro\xs_reserved_C
{\xs_assign_xstringresult{}{#3}% s'il ne reste plus rien, on renvoie vide
}
{\xs_exparg\xs_returnfirstsyntaxunit{\xs_reserved_C}\xs_reserved_D
\xs_ifx{\bgroup\xs_toks}% si la 1ère unité syntaxique est un groupe explicite
- {\advance\decimalpart1 % on augmente le compteur
- \xs_ifnum{\decimalpart=\xs_reserved_A\relax}% on est au groupe cherché lors de la profondeur courante ?
+ {\advance\xs_countb1 % on augmente le compteur
+ \xs_ifnum{\xs_countb=\xs_reserved_A\relax}% on est au groupe cherché lors de la profondeur courante ?
{\xs_ifx{\empty\xs_reserved_B}% on est à la profondeur maximale ?
{\xs_exparg\xs_assign_xstringresult{\xs_reserved_D}{#3}}% on renvoie ce groupe
{\xs_exparg{\expandafter\xs_StrFindGroup_i\xs_reserved_D}{\xs_reserved_B}[#3]}% on recommence avec ce groupe et les profondeurs de recherche restantes
@@ -974,7 +1046,7 @@
}%
}%
\xs_extractgroupnumber{#2}\xs_reserved_A\xs_reserved_B
- \decimalpart0
+ \xs_countb0
\xs_ifnum{\xs_reserved_A>0 }
{\def\xs_reserved_C{#1}}
{\let\xs_reserved_C\empty}%
@@ -996,7 +1068,7 @@
\begingroup
\xs_expandingroups
\xs_ifnum{#1>0 }
- {\integerpart#1 \decimalpart0 \gdef\groupID{0}\def\xs_nestlevel{0}%
+ {\xs_counta#1 \xs_countb0 \gdef\groupID{0}\def\xs_nestlevel{0}%
\def\xs_atendofgroup{\xs_endgroup_eaddtomacro\xs_reserved_B{\expandafter{\xs_reserved_B}}}%
\def\xs_atbegingroup{\let\xs_reserved_B\empty}%
\def\xs_atnextsyntaxunit{\xs_eeaddtomacro\xs_reserved_B{\xs_reserved_A}}%
@@ -1042,7 +1114,7 @@
H I S T O R I Q U E
------------------------------------------------------------------------------
v1.0 4/7/2008 : - Package achevé.
- 7/7/2008 : - Package publié sur CTAN.
+ 7/7/2008 : - Package publié sur CTAN.
------------------------------------------------------------------------------
v1.1 15/8/2008
- Le package ne nécessite plus LaTeX et est désormais utilisable sous
@@ -1229,3 +1301,8 @@ v1.84 21/07/2021
------------------------------------------------------------------------------
v1.85 14/01/2023
- 2 espaces parasites corrigés
+------------------------------------------------------------------------------
+v1.86 20/08/2023
+ - correction d'un bug dans \xs_IfSubStrBefore_i (signalé par Abbas Shams)
+ - les tests \IfDecimal et \IfInteger ne sont plus limités par le nombre de
+ chiffres de leurs parties décimale ou entière \ No newline at end of file