texlive[54915] Master/texmf-dist: simplekv (27apr20)
commits+karl at tug.org
commits+karl at tug.org
Mon Apr 27 23:17:47 CEST 2020
Revision: 54915
http://tug.org/svn/texlive?view=revision&revision=54915
Author: karl
Date: 2020-04-27 23:17:47 +0200 (Mon, 27 Apr 2020)
Log Message:
-----------
simplekv (27apr20)
Modified Paths:
--------------
trunk/Master/texmf-dist/doc/generic/simplekv/README
trunk/Master/texmf-dist/doc/generic/simplekv/simplekv-fr.pdf
trunk/Master/texmf-dist/doc/generic/simplekv/simplekv-fr.tex
trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.sty
trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.tex
Modified: trunk/Master/texmf-dist/doc/generic/simplekv/README
===================================================================
--- trunk/Master/texmf-dist/doc/generic/simplekv/README 2020-04-27 21:17:34 UTC (rev 54914)
+++ trunk/Master/texmf-dist/doc/generic/simplekv/README 2020-04-27 21:17:47 UTC (rev 54915)
@@ -3,9 +3,9 @@
L'extension
simplekv
- v0.1
+ v0.2
- 8 aout 2017
+ 27 avril 2020
___________________________________
Authors : Christian Tellechea
Modified: trunk/Master/texmf-dist/doc/generic/simplekv/simplekv-fr.pdf
===================================================================
(Binary files differ)
Modified: trunk/Master/texmf-dist/doc/generic/simplekv/simplekv-fr.tex
===================================================================
--- trunk/Master/texmf-dist/doc/generic/simplekv/simplekv-fr.tex 2020-04-27 21:17:34 UTC (rev 54914)
+++ trunk/Master/texmf-dist/doc/generic/simplekv/simplekv-fr.tex 2020-04-27 21:17:47 UTC (rev 54915)
@@ -22,7 +22,7 @@
\let\do\@makeother \dospecials
\ttfamily\small\@noligs
\make at car@active\<{\begingroup$\langle$\itshape}%
- \make at car@active\>{$\rangle$\endgroup}%
+ \make at car@active\>{\/$\rangle$\endgroup}%
\obeylines\obeyspaces
\def\code at ii##1#1{##1\par\medbreak\endgroup}%
\code at ii
@@ -126,25 +126,23 @@
\endgroup
\vskip2cm
\leftskip=.2\linewidth \rightskip=.2\linewidth \small
- Cette petite extension est une impl\xE9mentation d'un syst\xE8me dit \xE0 \xABcl\xE9/valeurs\xBB pour \TeX{} ou \LaTeX. Aucune fioriture inutile n'a \xE9t\xE9 cod\xE9e, elle comporte juste l'essentiel.
+ Cette petite extension est une impl\xE9mentation d'un syst\xE8me dit \xE0 \xAB\<cl\xE9s>/\<valeurs>\xBB pour \TeX{} ou \LaTeX. Elle comporte juste l'essentiel, aucune fioriture inutile n'a \xE9t\xE9 cod\xE9e et aucune extension tierce n'est n\xE9cessaire \xE0 son fonctionnement.
\end{titlepage}
\section{Cl\xE9s, valeurs}
-Lorsqu'une macro doit recevoir des param\xE8tres dont le nombre n'est pas fixe ou connu, il est commode de proc\xE9der par \<cl\xE9s> et \<valeurs>. Beaucoup d'extensions allant en ce sens existent d\xE9j\xE0.
-
-Le but de celle-ci n'est pas de grossir le nombre d\xE9j\xE0 trop grand de ces extensions, c'est simplement un morceau de l'extension \texttt{hlist} qui a \xE9t\xE9 converti en extension car ce syst\xE8me \<cl\xE9>/\<valeurs> est \xE9galement utilis\xE9 par l'extension \texttt{scratch}.\medskip
-
+Lorsqu'une macro doit recevoir des param\xE8tres dont le nombre n'est pas fixe ou connu, il est commode de proc\xE9der par \<cl\xE9s> et \<valeurs>.
+\medskip
Voici bri\xE8vement les d\xE9finitions et les limitations des structures mises \xE0 disposition :
\begin{itemize}
- \item une \<cl\xE9> est un mot d\xE9signant un param\xE8tre; il est form\xE9 de pr\xE9f\xE9rence avec des caract\xE8res de code de cat\xE9gorie 11 (lettres), 12 (autres caract\xE8res sauf la virgule) et 10 (l'espace). On peut cependant y mettre des caract\xE8res ayant d'autres codes de cat\xE9gorie, dans la limitation de ce qui est admis dans la primitive \verb|\detokenize|;
+ \item une \<cl\xE9> est un mot d\xE9signant un param\xE8tre; il est form\xE9 de pr\xE9f\xE9rence avec des caract\xE8res de code de cat\xE9gorie 11 (lettres), 12 (autres caract\xE8res sauf la virgule et le signe \verb|=|) et 10 (l'espace). On peut cependant y mettre des caract\xE8res ayant d'autres codes de cat\xE9gorie, dans la limitation de ce qui est admis dans la primitive \verb|\detokenize|; une \<cl\xE9>, m\xEAme si cela rev\xEAt peu de signification, peut \xEAtre vide;
\item la syntaxe pour assigner une \<valeur> \xE0 une \<cl\xE9> est : \hbox{\<cl\xE9>=\<valeur>};
\item les espaces qui pr\xE9c\xE8dent et qui suivent la \<cl\xE9> et la \<valeur> sont ignor\xE9s, mais \emph{pas ceux} qui se trouvent \xE0 l'int\xE9rieur de la \<cl\xE9> ou de la \<valeur>;
\item une \<valeur> est un \<code> arbitraire;
\item si une \<valeur> est entour\xE9e d'accolades, ces derni\xE8res seront retir\xE9es : \verb|<cl\xE9>=<valeur>| est donc \xE9quivalent \xE0 \verb|<cl\xE9>={<valeur>}|;
+ \item lorsqu'une valeur est entour\xE9e de \emph{plusieurs} imbrications d'accolades, seul le niveau externe est retir\xE9 et donc \verb|<cl\xE9>={{<valeur>}}| est compris comme \verb|<cl\xE9>={<valeur>}|;
\item lorsque plusieurs couples de \<cl\xE9s>/\<valeurs> doivent \xEAtre sp\xE9cifi\xE9s, ils sont s\xE9par\xE9s les uns des autres par des virgules;
\item une virgule ne peut figurer dans une \<valeur> que si la virgule est dans un niveau d'accolades; par exemple, \verb|foo=1,5| n'est pas valide car la \<valeur> s'\xE9tend jusqu'au 1. Il faudrait \xE9crire \verb|foo={1,5}| pour sp\xE9cifier une valeur de \verb|1,5|;
- \item lorsqu'une valeur est entour\xE9e de \emph{plusieurs} d'accolades, seul le niveau externe est retir\xE9;
\item les \<valeurs> sont stock\xE9es \emph{telles qu'elles sont lues} ; en particulier, aucun d\xE9veloppement n'est effectu\xE9;
\item les d\xE9finitions sont \emph{locales} : par cons\xE9quent, toute \<cl\xE9> d\xE9finie ou modifi\xE9e dans un groupe est restaur\xE9e \xE0 son \xE9tat ant\xE9rieur \xE0 la sortie du groupe;
\item des \<cl\xE9>/\<valeurs> destin\xE9es \xE0 une m\xEAme macro ou \xE0 un m\xEAme usage doivent \xEAtre regroup\xE9es dans un ensemble dont on choisit le nom. Un tel ensemble est appel\xE9 \<trousseau>.
@@ -152,95 +150,162 @@
\section{Commandes mises \xE0 disposition}
-\paragraph{La macro \texttt{\char`\\setKVdefault}}
-Cette commande est un pr\xE9alable \xE0 toute utilisation de \<cl\xE9s> puisqu'elle d\xE9finit un \<trousseau> contenant des \<cl\xE9s> et leurs \<valeurs> par d\xE9faut.
+\paragraph{Les macro \texttt{\char`\\setKV} et \texttt{\char`\\setKVdefault}}
+Ces commandes d\xE9finissent des \<cl\xE9s> et leur assignent des \<valeurs> dans un \<trousseau>. La seule diff\xE9rence entre les deux macros est que \verb|\setKVdefault|, en plus d'assigner les \<valeurs> aux \<cl\xE9s>, les sauvegarde en vue d'une restauration ult\xE9rieure avec \verb|\restoreKV|.
On \xE9crit
-\begin{center} \verb|\setKVdefault[<trousseau>]{<cl\xE9 1>=<valeur 1>,<cl\xE9 2>=<valeur 2>,...,<cl\xE9 i>=<valeur i>}|
-\end{center}
+\code|\setKV[<trousseau>]{<cl\xE9 1>=<valeur 1>,<cl\xE9 2>=<valeur 2>,...,<cl\xE9 n>=<valeur n>}|
Il faut noter que
\begin{itemize}
- \item l'argument entre accolades contenant les \<cl\xE9s> et les \<valeurs> ne peut pas \xEAtre vide;
+ \item l'argument entre accolades contenant les \<cl\xE9s> et les \<valeurs> ne devrait pas \xEAtre vide, sauf \xE0 vouloir d\xE9finir une \<cl\xE9> bool\xE9enne vide \xE9gale \xE0 \texttt{true};
+ \item lors de la lecture des \<cl\xE9s>/\<valeurs>, la virgule et le signe \xE9gal ont leurs catcodes rendus \xE9gaux \xE0 12;
\item le nom du \<trousseau>, bien qu'entre crochet, est \emph{obligatoire}, mais il peut \xEAtre vide bien que cela ne soit pas conseill\xE9;
- \item si plusieurs \<cl\xE9s> sont identiques, seule la derni\xE8re \<valeur> sera prise en compte;
- \item les \<valeurs> peuvent \xEAtre bool\xE9ennes, auquel cas, elles \emph{doivent} \xEAtre \xAB\texttt{true}\xBB ou \xAB\texttt{false}\xBB en caract\xE8res de catcode 11;
+ \item si une m\xEAme \<cl\xE9> figure plusieurs fois, la \<valeur> retenue sera celle de la derni\xE8re assignation;
+ \item les \<valeurs> peuvent \xEAtre bool\xE9ennes auquel cas, elles \emph{doivent} \xEAtre \xAB\texttt{true}\xBB ou \xAB\texttt{false}\xBB en caract\xE8res de catcode 11;
\item si une \<valeur> est omise, elle est comprise comme \xE9tant \xAB\texttt{true}\xBB. Ainsi, \xE9crire
- \code|\setKVdefault[foo]{mon bool}|
+ \code|\setKV[foo]{mon bool}|
est \xE9quivalent \xE0
- \code|\setKVdefault[foo]{mon bool = true}|
- \item il est \emph{d\xE9conseill\xE9} d'ex\xE9cuter plusieurs fois \verb|\setKVdefault| pour le m\xEAme \<trousseau>. Si cela est indispensable, il convient de red\xE9finir \emph{toutes} les \<cl\xE9s> qui figuraient dans les pr\xE9c\xE9dents appels de \verb|\setKVdefault|.
+ \code|\setKV[foo]{mon bool = true}|
\end{itemize}
-\paragraph{La macro \texttt{\char`\\setKV}}
-Cette macro fonctionne selon les m\xEAmes principes et limitations que \verb|\setKVdefault|, sauf qu'elle red\xE9finit une ou plusieurs \<cl\xE9s> dont les \<valeurs> ont pr\xE9c\xE9demment \xE9t\xE9 d\xE9finies par \verb|\setKVdefault|.
-
-Si une \<cl\xE9> n'a pas \xE9t\xE9 pr\xE9d\xE9finie par \verb|\setKVdefault|, une erreur sera \xE9mise.
-
\paragraph{La macro \texttt{\char`\\useKV}}
Cette macro purement d\xE9veloppable renvoie la \<valeur> pr\xE9alablement associ\xE9e \xE0 une \<cl\xE9> dans un \<trousseau>:
-\code|\useKV[<trousseau>]{<cl\xE9>}|
+ \code|\useKV[<trousseau>]{<cl\xE9>}|
Il faut noter que
\begin{itemize}
- \item si la \<cl\xE9> n'a pas \xE9t\xE9 pr\xE9d\xE9finie par \verb|\setKVdefault|, une erreur sera \xE9mise;
+ \item si la \<cl\xE9> n'a pas \xE9t\xE9 d\xE9finie, une erreur sera \xE9mise;
\item si la \<cl\xE9> est bool\xE9enne, le texte \xAB\texttt{true}\xBB ou \xAB\texttt{false}\xBB sera renvoy\xE9;
\item il faut 2 d\xE9veloppements \xE0 \verb|\useKV[<trousseau>]{<cl\xE9>}| pour donner la \<valeur> associ\xE9e \xE0 la \<cl\xE9>.
\end{itemize}
-\exemple|\setKVdefault[foo]{nombre = 5 , lettres= AB \textit{CD} , mon bool}
-a) \useKV[foo]{nombre}.\qquad b) \useKV[foo]{lettres}.\qquad c) \useKV[foo]{mon bool}.\par
+\exemple|\setKV[foo]{nombre = 5 , lettres= AB \textit{CD} , mon bool}
+a) \useKV[foo]{nombre}.\qquad b) \useKV[foo]{lettres}.\qquad c) \useKV[foo]{mon bool}.
+
\setKV[foo]{lettres = X Y Z \textbf{123} }
a) \useKV[foo]{nombre}.\qquad b) \useKV[foo]{lettres}.\qquad c) \useKV[foo]{mon bool}.|
-\paragraph{La macro \texttt{\char`\\useKVdefault}}
-L'ex\xE9cution de cette macro par \verb|\useKVdefault[<trousseau>]| r\xE9initialise toutes les \<cl\xE9s> du \<trousseau> aux \<valeurs> qui ont \xE9t\xE9 d\xE9finies lors de l'ex\xE9cution \verb|\setKVdefault|.
+\paragraph{La macro \texttt{\char`\\restoreKV}}
+La macro \verb|\restoreKV[<trousseau>]| r\xE9initialise toutes les \<cl\xE9s> du \<trousseau> aux \<valeurs> qui ont \xE9t\xE9 d\xE9finies lors de l'ex\xE9cution \verb|\setKVdefault|. La macro \verb|\useKVdefault[<trousseau>]| lui est \xE9quivalente.
\paragraph{La macro \texttt{\char`\\ifboolKV}}
Cette macro permet, selon la valeur d'une \<cl\xE9 bool\xE9enne>, d'ex\xE9cuter un des deux \<codes> donn\xE9s. La syntaxe est
-\code|\ifboolKV[<trousseau>]{<cl\xE9>}{<code si "true">}{<code si "false>}|
+ \code|\ifboolKV[<trousseau>]{<cl\xE9>}{<code si "true">}{<code si "false>}|
La macro est purement d\xE9veloppable, elle n\xE9cessite 2 d\xE9veloppements pour donner l'un des deux codes, et exige que la \<cl\xE9> soit bool\xE9enne sans quoi un message d'erreur est \xE9mis.
\paragraph{La macro \texttt{\char`\\showKV}}
Cette commande \xE9crit dans le fichier \texttt{log} la \<valeur> assign\xE9e \xE0 une \<cl\xE9> d'un \<trousseau>:
-\code|\showKV[<trousseau>]{<cl\xE9>}|
+ \code|\showKV[<trousseau>]{<cl\xE9>}|
Si la \<cl\xE9> n'est pas d\xE9finie, \xAB\texttt{not defined}\xBB est affich\xE9 dans le fichier log.
+\section{Code}
+En plus d'une \<valeur>, un \<code> arbitraire peut \xEAtre assign\xE9 \xE0 n'importe quelle \<cl\xE9>. Pour ce faire, on \xE9crit
+\begin{center} \verb|\defKV[<trousseau>]{<cl\xE9 1>=<code 1>,<cl\xE9 2>=<code 2>,...,<cl\xE9 n>=<code n>}|
+\end{center}
+Chaque \<code> peut contenir \verb|#1| qui repr\xE9sente la \<valeur> de la \<cl\xE9>. Ce \<code> est ex\xE9cut\xE9 lorsque une \<valeur> est assign\xE9e \xE0 la \<cl\xE9> avec \verb|\setKV|, \verb|\setKVdefault| ou \verb|\restoreKV|.
+\bigbreak
+
+Ainsi d\xE9clarer
+ \code|\defKV[x]{ mykey = \def\foo{\textbf{#1}}|
+va d\xE9finir une macro \verb|\foo| d\xE8s que la \<cl\xE9> \xAB\texttt{mykey}\xBB va \xEAtre d\xE9finie (ou red\xE9finie) et donc, si l'on \xE9crit
+ \code|\setKV[x]{ mykey = bonjour }|
+le code qui est ex\xE9cut\xE9 en coulisses est
+ \code|\long\def\foo{\textbf{bonjour}}|
+
+\exemple|\defKV[x]{ mykey = \def\foo{\textbf{#1}} }
+\setKV[x]{ mykey = bonjour }% d\xE9finition
+1) \meaning\foo\par
+2) \useKV[x]{ mykey }
+
+\setKV[x]{ mykey = hello }% red\xE9finition
+3) \meaning\foo\par
+4) \useKV[x]{ mykey }|
+
+La macro \verb|\testboolKV| permet de tester, par exemple dans un \<code>, si son argument est \xABtrue\xBB ou \xABfalse\xBB
+ \code|\testboolKV{<argument>}{<code si true>}{<code si false>}|
+
+La macro est purement d\xE9veloppable, elle n\xE9cessite 2 d\xE9veloppements pour donner l'un des deux codes, et exige que l'\<argument> soit bool\xE9en sans quoi un message d'erreur est \xE9mis.
+
+\exemple|\defKV[x]{ x = \def\test{\testboolKV{#1}{test positif}{test n\xE9gatif}}}
+\setKV[x]{ x = true}
+1) \test
+
+\setKV[x]{ x= false}
+2) \test|
+Toute autre valeur que \xAB\verb|true|\xBB ou \xAB\verb|false|\xBB g\xE9n\xE8rera un message d'erreur.
+
\section{Un exemple d'utilisation}
-Voici comment on pourrait programmer une macro qui affiche un cadre sur une ligne. Pour cela les \<cl\xE9s> suivantes seront utilis\xE9es:
+Voici comment on pourrait programmer une macro qui affiche un cadre sur une ligne, gr\xE2ce \xE0 la macro \verb|\fbox| et l'environnement \verb|center| de \LaTeX. Pour cela les \<cl\xE9s> suivantes seront utilis\xE9es:
\begin{itemize}
\item le bool\xE9en \texttt{inline} qui affichera le cadre dans le texte s'il est vrai et sur une ligne d\xE9di\xE9 s'il est faux;
- \item \texttt{left code} et \texttt{right code} qui sont deux codes ex\xE9cut\xE9s avant et apr\xE8s le cadre si le bool\xE9en est faux (par d\xE9faut : \verb|\hfill| et \verb|\hfill| pour un centrage sur la ligne);
\item \texttt{sep} qui est une dimension mesurant la distance entre le texte et le cadre (par d\xE9faut \texttt{3pt});
- \item \texttt{width} qui est la largeur des traits du cadre (par d\xE9faut \texttt{0.5pt}).
+ \item \texttt{width} qui est la largeur des traits du cadre (par d\xE9faut \texttt{0.5pt});
+ \item \texttt{style} qui contient le code ex\xE9cut\xE9 avant le texte.
\end{itemize}
-\exemple|\setKVdefault[frame]{inline , left code = \hfill, right code = \hfill, sep = 3pt, width=0.5pt }
+Une premi\xE8re fa\xE7on de faire, sans recours \xE0 \verb|\defKV|;
+\exemple|\setKVdefault[frame]{
+ sep = 3pt,
+ line width = 0.5pt,
+ style = \bfseries,
+ inline
+ }
\newcommand\frametxt[2][]{%
+ \restoreKV[frame]% revenir au valeurs par d\xE9faut
\setKV[frame]{#1}% lit les arguments optionnels
- \ifboolKV[frame]{inline}{}{\par\noindent\useKV[frame]{left code}}%
- \fboxsep=\useKV[frame]{sep}\relax
- \fboxrule=\useKV[frame]{width}\relax
- \fbox{#2}%
- \ifboolKV[frame]{inline}{}{\useKV[frame]{right code}\null\par}%
+ \fboxsep = \useKV[frame]{sep}
+ \fboxrule= \useKV[frame]{line width}
+ \ifboolKV[frame]{inline}
+ {}
+ {\begin{center}}%
+ \fbox{\useKV[frame]{style}#2}%
+ \ifboolKV[frame]{inline}
+ {}
+ {\end{center}}%
}
-Un essai en ligne par d\xE9faut \frametxt{essai} puis un autre \frametxt[sep=5pt,width=2pt]{essai}
-et un dernier \frametxt[sep=0.5pt]{essai}.
+Un essai en ligne par d\xE9faut \frametxt{essai} puis un autre \frametxt[sep=5pt,line width=2pt]{essai}
+et un dernier \frametxt[sep=1pt,style=\itshape]{essai}.
-\useKVdefault[frame]% revenir au valeurs par d\xE9faut
-Un essai centr\xE9 \frametxt[inline = false]{essai centr\xE9}
-un autre fer \xE0 gauche \frametxt[left code={}]{essai \xE0 gauche}
-un dernier indent\xE9 \frametxt[left code=\hskip 5em, right code={}, sep=1pt, width=2pt]{essai indent\xE9}|
+Un essai hors ligne : \frametxt[inline = false, style=\bfseries\color{red}]{essai centr\xE9}|
+Dans l'exemple repris ci-dessous et gr\xE2ce \xE0 \verb|\defKV|, on stocke tous les param\xE8tres lors de leur assignation. Il y a bien moins de verbosit\xE9 dans le code de \verb|frametxt| ce qui le rend plus l\xE9ger et plus lisible.
+\exemple|\defKV[frame]{%
+ sep = {\fboxsep = #1 },
+ line width = {\fboxrule= #1 },
+ inline = \testboolKV{#1}
+ {\def\hookpre{}\def\hookpost{}}
+ {\def\hookpre{\begin{center}}\def\hookpost{\end{center}}},
+ style = \def\fstyle{#1}
+}
+\setKVdefault[frame]{
+ sep = 3pt,
+ line width = 0.5pt,
+ style = \bfseries,
+ inline
+ }
+\newcommand\frametxt[2][]{%
+ \restoreKV[frame]% revenir au valeurs par d\xE9faut
+ \setKV[frame]{#1}% lit les arguments optionnels
+ \hookpre
+ \fbox{\fstyle #2}%
+ \hookpost
+}
+Un essai en ligne par d\xE9faut \frametxt{essai} puis un autre \frametxt[sep=5pt,line width=2pt]{essai}
+et un dernier \frametxt[sep=1pt,style=\itshape]{essai}.
+
+Un essai hors ligne : \frametxt[inline = false, style=\bfseries\color{red}]{essai centr\xE9}|
+
+
\section{Le code}
Le code ci-dessous est l'exact verbatim du fichier \verb|simplekv.tex| :
\lstinputlisting[
language=TeX,
- moretexcs={unless,ifcsname,ifdefined,detokenize,numexpr,dimexpr,glueexpr,unexpanded},
+ moretexcs={unless,ifcsname,ifdefined,detokenize,numexpr,dimexpr,glueexpr,unexpanded,expanded},
basicstyle=\small\ttfamily\color{black!25},
identifierstyle=\bfseries\color{white},%
backgroundcolor=\color{black!85},
@@ -264,7 +329,7 @@
numbersep=1em,
classoffset=1,
alsoletter={\_},
- morekeywords={setKVdefault,setKV,useKVdefault,useKV,ifboolKV,},
+ morekeywords={setKVdefault,setKV,useKVdefault,useKV,ifboolKV,defKV,testboolKV,showKV},
keywordstyle=\bfseries\color{red!85!black},
classoffset=0,
]{simplekv.tex}
Modified: trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.sty
===================================================================
--- trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.sty 2020-04-27 21:17:34 UTC (rev 54914)
+++ trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.sty 2020-04-27 21:17:47 UTC (rev 54915)
@@ -1,4 +1,5 @@
% !TeX encoding = ISO-8859-1
+\def\skvfromSTY{}
\input simplekv.tex
\ProvidesPackage{simplekv}[\skvdate\space v\skvver\space Simple keyval package (CT)]
\endinput
\ No newline at end of file
Modified: trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.tex
===================================================================
--- trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.tex 2020-04-27 21:17:34 UTC (rev 54914)
+++ trunk/Master/texmf-dist/tex/generic/simplekv/simplekv.tex 2020-04-27 21:17:47 UTC (rev 54915)
@@ -7,9 +7,9 @@
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
\def\skvname {simplekv} %
-\def\skvver {0.1} %
+\def\skvver {0.2} %
% %
-\def\skvdate {2017/08/08} %
+\def\skvdate {2020/04/27} %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
@@ -27,11 +27,10 @@
% This work has the LPPL maintenance status `maintained'.
%
% The Current Maintainer of this work is Christian Tellechea
-% Copyright : Christian Tellechea 2017
% email: unbonpetit at netc.fr
% Commentaires, suggestions et signalement de bugs bienvenus !
% Comments, bug reports and suggestions are welcome.
-% Copyright: Christian Tellechea 2017
+% Copyright: Christian Tellechea 2017-2020
% --------------------------------------------------------------------
% L'extension simplekv est compos\xE9e des 5 fichiers suivants :
% - code : simplekv (.tex et .sty)
@@ -39,284 +38,157 @@
% - fichier lisezmoi : README
% --------------------------------------------------------------------
-\expandafter\edef\csname skv_restorecatcode\endcsname{\catcode`\noexpand\_=\the\catcode`\_\relax}
+%##########################################
+%################ Pr\xE9alable ###############
+%##########################################
+\csname skvloadonce\endcsname
+\let\skvloadonce\endinput
+\ifdefined\skvfromSTY\else
+ \immediate\write -1 {%
+ Package: \skvname\space\skvdate\space v\skvver\space Simple keyval package (CT)%
+ }%
+\fi
+%##########################################
+%############ Gestion catcodes ############
+%##########################################
+\begingroup
+ \def\X#1{\catcode\number`#1=\number\catcode`#1\relax}
+ \expandafter\xdef\csname skv_restorecatcode\endcsname{\X\,\X\=\X\_}
+\endgroup
\catcode`\_11
-
-%################################################
-%################################################
-% Cette macro est \xE9quivalente \xE0 0 et sert notamment \xE0 stopper le d\xE9veloppement
-% de \romannumeral
+\chardef\skv_other12
+\catcode`\,\skv_other\catcode`\=\skv_other
+%##########################################
+%############ Macros auxilaires ###########
+%##########################################
\chardef\skv_stop 0
-
-% D\xE9finition du quark, notamment ins\xE9r\xE9 \xE0 la fin d'une liste pour en reconnaitre
-% la fin et stopper la r\xE9cursivit\xE9
-\def\skv_quark{\skv_quark}
-
-% Voici les macros habituelles de s\xE9lection d'arguments
\long\def\skv_first#1#2{#1}
\long\def\skv_second#1#2{#2}
-
-% Voici la macro pour 1-d\xE9velopper ou 2-d\xE9velopper le 2e argument (le 1er \xE9tant
-% d\xE9pouill\xE9 des accolades)
-% \skv_exparg{<a>}{<b>} devient <a>{<b>}
-% \skv_eearg{<a>}{<b>} devient <a>{**<b>}
-\long\def\skv_exparg#1#2{\expandafter\skv_exparg_i\expandafter{#2}{#1}}%
-\long\def\skv_eearg#1#2{\expandafter\expandafter\expandafter\skv_exparg_i\expandafter\expandafter\expandafter{#2}{#1}}%
-\long\def\skv_exparg_i#1#2{#2{#1}}
-
-% Et la macro pour 1-d\xE9velopper le 2e argument (le 1er et le 2e argument sont
-% d\xE9pouill\xE9s des accolades)%
-% \skv_expafter{<a>}{<b>} devient <a><*b>
-\long\def\skv_expafter#1#2{\expandafter\skv_expafter_i\expandafter{#2}{#1}}
+\long\def\skv_gob#1{}
+\long\def\skv_exe#1{#1}
+\expandafter\def\expandafter\skv_gobspace\space{}% pour garder la compatibilit\xE9
+\long\def\skv_earg#1#2{\expandafter\skv_earg_i\expandafter{#2}{#1}}\let\skv_exparg\skv_earg
+\long\def\skv_eearg#1#2{\expandafter\expandafter\expandafter\skv_earg_i\expandafter\expandafter\expandafter{#2}{#1}}
+\long\def\skv_earg_i#1#2{#2{#1}}
+\long\def\skv_expafter#1#2{\expandafter\skv_expafter_i\expandafter{#2}{#1}}% {<a>}{<b>} devient <a><*b>
\long\def\skv_expafter_i#1#2{#2#1}
-
-% Enfin, la macro pour former le nom du 2e argument (le 1er est d\xE9pouill\xE9 des
-% accolades)
-% \skv_argcsname{<a>}{<b>} devient <a>\<b>
-\def\skv_argcsname#1#{\skv_argcsname_i{#1}}
-\def\skv_argcsname_i#1#2{\skv_expafter{#1}{\csname#2\endcsname}}
-
-\def\skv_eaddtomacro#1#2{\skv_exparg{\skv_exparg{\def#1}}{\expandafter#1#2}}
-
-%################################################
-%################ macros de test ################
-%################################################
-% Voici quelques macros \xE0 s\xE9lection d'arguments pour les tests
\def\skv_ifcsname#1{\ifcsname#1\endcsname\expandafter\skv_first\else\expandafter\skv_second\fi}
\long\def\skv_ifx#1{\ifx#1\expandafter\skv_first\else\expandafter\skv_second\fi}
-\long\def\skv_ifempty#1{\skv_exparg\skv_ifx{\expandafter\relax\detokenize{#1}\relax}}
-
-% Ces macros sont utiles pour \skv_removeextremespaces, qui retire les
-% espaces extr\xEAmes de son argument
-% Voir codes 320-324 (http://progtex.fr/wp-content/uploads/2014/09/code.txt)
-% et pages 339-343 de "Apprendre \xE0 programmer en TeX"
-\long\def\skv_ifspacefirst#1{\expandafter\skv_ifspacefirst_i\detokenize{#10} \_nil}
-\long\def\skv_ifspacefirst_i#1 #2\_nil{\skv_ifempty{#1}}
-\expandafter\def\expandafter\skv_gobspace\space{}
-\def\skv_removefirstspaces{\romannumeral\skv_removefirstspaces_i}
-\long\def\skv_removefirstspaces_i#1{\skv_ifspacefirst{#1}{\expandafter\skv_removefirstspaces_i\expandafter{\skv_gobspace#1}}{\skv_stop#1}}
-\begingroup
- \catcode0 12
- \long\gdef\skv_removelastspaces#1{\romannumeral\skv_removelastspaces_i#1^^00 ^^00\_nil}
- \long\gdef\skv_removelastspaces_i#1 ^^00{\skv_removelastspaces_ii#1^^00}
- \long\gdef\skv_removelastspaces_ii#1^^00#2\_nil{\skv_ifspacefirst{#2}{\skv_removelastspaces_i#1^^00 ^^00\_nil}{\skv_stop#1}}
-\endgroup
-\long\def\skv_removeextremespaces#1{%
- \romannumeral\expandafter\expandafter\expandafter\skv_removelastspaces\expandafter\expandafter\expandafter
- {\expandafter\expandafter\expandafter\skv_stop\skv_removefirstspaces{#1}}%
+\long\def\skv_ifempty#1{\skv_ifempty_i#1\_nil\_nil\skv_second\skv_first\__nil}%
+\long\def\skv_ifempty_i#1#2\_nil#3#4#5\__nil{#4}
+\def\skv_stripsp#1{%
+\long\def\skv_stripsp##1##2{\expanded{\skv_stripsp_i\_marksp##2\__nil\_marksp#1\_marksp\_nil{##1}}}%
+\long\def\skv_stripsp_i##1\_marksp#1##2\_marksp##3\_nil{\skv_stripsp_ii##3##1##2\__nil#1\__nil\_nil}%
+\long\def\skv_stripsp_ii##1#1\__nil##2\_nil{\skv_stripsp_iii##1##2\_nil}%
+\long\def\skv_stripsp_iii##1##2\__nil##3\_nil##4{\unexpanded{##4{##2}}}%
+}\skv_stripsp{ }
+%##########################################
+%########## Macros de d\xE9finition ##########
+%##########################################
+\def\setKVdefault{\let\skv_find_kv_i\skv_find_kv_nocode\skv_readKV\skv_exe}
+\def\setKV {\let\skv_find_kv_i\skv_find_kv_nocode\skv_readKV\skv_gob}
+\def\defKV {\let\skv_find_kv_i\skv_find_kv_code \skv_readKV\skv_gob}
+\def\skv_readKV{%
+ \edef\skv_restorecatcode{\catcode44=\the\catcode44 \relax\catcode61=\the\catcode61 \relax}%
+ \catcode44\skv_other\catcode61\skv_other
+ \skv_readKV_i
}
-
-%################################################
-%############## syst\xE8me cl\xE9/valeur ##############
-%################################################
-% Ceci est le bool\xE9en indiquant si la lecture de <cl\xE9s>=<valeurs> d\xE9finit les
-% <cl\xE9s> _par d\xE9faut_ ou qu'il s'agit d'une _red\xE9finition_ des <cl\xE9s> d\xE9j\xE0
-% existantes
-\newif\ifskv_default
-
-% macros chapeau appelant la m\xEAme macro avec le bool\xE9en pr\xE9alablement d\xE9fini
-\def\setKVdefault{\skv_defaulttrue\skv_readKV}
-\def\setKV{\skv_defaultfalse\skv_readKV}
-
-% L'argument obligatoire #1 est le nom du <trousseau> et #2 est l'ensemble
-% des <cl\xE9s>=<valeurs>
-\def\skv_readKV[#1]#2{%
- \skv_ifempty{#2}
-% Si aucune <cl\xE9s>=<valeurs> alors qu'on d\xE9finit les <valeurs> par d\xE9faut,
-% message d'erreur et on s'arr\xEAte l\xE0
- {\ifskv_default\errmessage{No key/val found, no default key/val defined}\fi}
-% Sinon, initialiser \xE0 <vide> la macro \skv_[<trousseau>] uniquement si on
-% cr\xE9\xE9 les <valeurs> par d\xE9faut
- {\ifskv_default\skv_argcsname\let{skv_[#1]}\empty\fi
-% Puis on passe aux choses s\xE9rieuses, on va lire un par un tous les \xE9l\xE9ments
-% <cl\xE9>=<valeur> (contenus dans #2) en mettant le quark comme dernier couple
-% pour montrer la fin de la liste
- \skv_readKV_i[#1]#2,\skv_quark,%
- }%
+\long\def\skv_readKV_i#1[#2]#3{%
+ #1{\expandafter\def\csname skv_[#2]\endcsname{#3}}% ex\xE9cute (si \defKV) ou pas
+ \def\skv_setname{#2}%
+ \skv_readKV_ii#3,\__,%
+ \skv_restorecatcode
}
+\long\def\skv_readKV_ii#1,{\skv_readKV_iii\skv_find_kv#1=true=\_nil\skv_find_kv\__\__nil}% si #1=\__ ne rien faire sinon \skv_find_kv#1=true=\_nil
+\long\def\skv_readKV_iii#1\skv_find_kv\__#2\__nil{#1}
-\def\skv_readKV_i[#1]#2,{%
-% #2 est le premier couple "<cl\xE9>=<valeur>" de la liste qui reste \xE0 traiter :
-% tout d'abord, on se d\xE9barrasse des espaces extr\xEAmes
- \skv_eearg{\def\__temp}{\skv_removeextremespaces{#2}}%
-% Si ce qui en r\xE9sulte est \xE9gal au <quark>,
- \skv_ifx{\__temp\skv_quark}
-% alors, on a fini et on ne fait rien (fin du processus)
- {}
-% Sinon, si ce qui en r\xE9sulte est vide (le couple "<cl\xE9>=<valeur>" \xE9tait donc
-% vide ou compos\xE9 d'un espace)
- {\skv_ifx{\__temp\empty}
-% On a fini et on ne fait rien (fin du processus)
- {}
-% dans le cas contraire, on va isoler la <cl\xE9> et la <valeur> du couple lu en
-% prenant soin de mettre \xE0 la fin "=<quark>" pour se pr\xE9munir du cas o\xF9
-% "<cl\xE9>=<valeur>" ne contient que la "<cl\xE9>" et pas de signe "=", ce qui
-% ferait planter la macro \xE0 arguments d\xE9limit\xE9s
- {\expandafter\skv_find_kv\__temp=\skv_quark\_nil[#1]%
- }%
-% Lorsque la <cl\xE9> et la <valeur> est trouv\xE9e et stock\xE9e, recommencer et aller
-% lire le prochain couple "<cl\xE9>=<valeur>"
- \skv_readKV_i[#1]%
- }%
+\long\def\skv_find_kv#1=#2=#3\_nil{%
+ \edef\__key{_[\skv_setname]_\skv_stripsp\detokenize{#1}}%
+ \skv_stripsp\skv_find_kv_i{#2}%
+ \skv_readKV_ii
}
-
-% Voici la macro \xE0 arguments d\xE9limit\xE9s \xE0 qui on a transmis
-% <cl\xE9>=<valeur>=<quark> (si <cl\xE9>=<valeur> est l'\xE9l\xE9ment lu)
-% ou
-% <cl\xE9>=<quark> (si <cl\xE9> est seule)
-% et qui va isoler la <cl\xE9> de la <valeur>.
-\def\skv_find_kv#1=#2\_nil[#3]{%
-% #1 est ce qui se trouve avant le _premier_ signe "=" et
-% #2 est ce qui se trouve entre le premier signe "=" et le \_nil
-% Pour la <cl\xE9>, pas de probl\xE8me, c'est _obligatoirement_ ce qui est avant le
-% signe "=", que ce signe soit pr\xE9sent dans le couple lu ou pas puisqu'on y a
-% rajout\xE9 "=<quark>".
-% On \xE9limine les espaces extr\xEAmes pour obtenir la <cl\xE9> d\xE9finitive stock\xE9e dans
-% \__key (il faut 2-d\xE9velopper \skv_removeextremespaces pour qu'elle donne son
-% argument sans espace extr\xEAme)
- \edef\__key{\detokenize\expandafter\expandafter\expandafter{\skv_removeextremespaces{#1}}}%
-% Pour la <valeur>, on lui \xF4te d'abord les espaces extr\xEAmes
- \skv_eearg{\def\__val}{\skv_removeextremespaces{#2}}%
- \skv_ifx{\__val\skv_quark}
-% Si elle est \xE9gale au <quark>, alors la <valeur> vaut "true"
- {\def\__val{true}}%
-% Sinon, \xF4ter "=<quark>" de la fin de l'argument #2, \xE9liminer les espaces
-% extr\xEAmes de ce qui en r\xE9sulte et stocker le tout dans \__val (tout ceci est
-% effectu\xE9 par la macro \skv_find_val <valeur>=<quark>)
- {\skv_find_val#2}%
-% Si on lit les <cl\xE9s>=<valeurs> par d\xE9faut,
- \ifskv_default
-% assigner \xE0 la macro "\skv_[<trousseau>]_<cl\xE9>" la <valeur> trouv\xE9e
- \skv_argcsname\let{skv_[#3]_\detokenize\expandafter{\__key}}\__val
-% Puis ajouter \xE0 la macro "\skv_[<trousseau>]", qui a \xE9t\xE9 pr\xE9alablement
-% initialis\xE9e \xE0 <vide> :
-% \def\skv_[<trousseau>]_<cl\xE9>{<valeur>}
- \skv_argcsname\skv_eaddtomacro{skv_[#3]}%
- {\expandafter\def\csname skv_[#3]_\detokenize\expandafter{\__key}\expandafter\endcsname\expandafter{\__val}}%
-% C'est selon ce hashage que sont enregistr\xE9s les couples <cl\xE9>/<valeur> : les
-% <cl\xE9s> sont contenues dans les noms des macros tandis que les <valeurs> sont
-% les textes de remplacement de ces macros.
-% C'est rapide et simple :
-% a) pour trouver une <valeur> d'apr\xE8s sa <cl\xE9>, il suffit de d\xE9velopper la
-% macro \skv_[<trousseau>]_<cl\xE9>
-% b) pour red\xE9finir une <cl\xE9>, il suffit de red\xE9finir cette macro avec la
-% nouvelle <valeur>
-% c) il est facile de v\xE9rifier qu'une <cl\xE9> existe en v\xE9rifiant que la macro
-% associ\xE9e est d\xE9finie, la primitive \ifcsname le fait tr\xE8s bien
-% d) en revanche, on ne peut pas faire de recherche _inverse_ de fa\xE7on
-% pratique : il est en effet plus difficile de trouver la (ou les) <cl\xE9>
-% contenant une <valeur> donn\xE9e, mais cette limitation n'a pas grande
-% importance ici (je ne sais pas si les autres syst\xE8mes de <cl\xE9>/<valeur>
-% sont programm\xE9s de telle sorte que cela soit simple...)
-% Bref, la macro "\skv_[<trousseau>]" contient donc _toutes_ les d\xE9finitions
-% des macros d\xE9finissant les <cl\xE9s>/<valeurs> _par d\xE9faut_ et ex\xE9cuter
-% "\skv_[<trousseau>]" remet donc toutes les <cl\xE9s> \xE0 leur <valeur> par d\xE9faut.
- \else
-% Dans le cas o\xF9 on _lit_ des nouvelles <valeurs> pour des <cl\xE9s>
- \skv_ifcsname{skv_[#3]_\__key}
-% Si la <cl\xE9> existe (ssi la macro "\skv_[<trousseau>]_<cl\xE9>" est d\xE9finie),
-% alors assigner la <valeur> \xE0 cette macro
- {\skv_argcsname\let{skv_[#3]_\__key}\__val}%
-% Sinon, \xE9mettre un message d'erreur et ne rien faire de plus
- {\errmessage{Key "\__key" is not defined: nothing is modified}}%
+\long\def\skv_find_kv_nocode#1{%
+ \expandafter\def\csname skv\__key\endcsname{#1}%\__val% stocker la cl\xE9
+ \ifcsname skvcode\__key\endcsname% si le code correspondant existe
+ \csname skvcode\__key\endcsname{#1}% ex\xE9cute le code
\fi
}
+\long\def\skv_find_kv_code#1{%
+ \expandafter\def\csname skvcode\__key\endcsname##1{#1}%
+}
-% Cette macro \xE0 qui on a transmis "<valeur>=<quark>" ne garde que <valeur>, en
-% \xF4te les espaces extr\xEAmes et stocke le r\xE9sultat dans \__val
-\def\skv_find_val#1=\skv_quark{\skv_eearg{\def\__val}{\skv_removeextremespaces{#1}}}
-
-% Cette macro remet toutes les <cl\xE9s> \xE0 leur <valeurs> par d\xE9faut en ex\xE9cutant
-% la macro "\skv_[<trousseau>]"
-\def\useKVdefault[#1]{%
+\def\restoreKV[#1]{%
\skv_ifcsname{skv_[#1]}
- {\csname skv_[#1]\endcsname}
-% Si la macro "\skv_[<trousseau>]" n'existe pas, message d'erreur
- {\errmessage{Undefined set of keys "#1"}}%
+ {\skv_eearg{\setKV[#1]}{\csname skv_[#1]\endcsname}}
+ {\errmessage{Undefined or not saved set of keys "#1"}}%
}
-
-% Cette macro donne la <valeur> correspondant \xE0 la <cl\xE9> contenue dans #2
-\def\useKV[#1]#2{%
-% Avec \romannumeral, la <valeur> sera obtenue apr\xE8s _2_ d\xE9veloppements de
-% \useKV[<trousseau>]{<cl\xE9>}
- \romannumeral\skv_ifempty{#2}
-% Si la <cl\xE9> est vide, message d'erreur (il ne peut y avoir de <valeur>
-% associ\xE9e \xE0 une <cl\xE9> vide)
- {\skv_stop\errmessage{Key name missing}}
- {\skv_ifcsname{skv_[#1]_\skv_removeextremespaces{#2}}
-% Si la macro "\skv_[<trousseau>]_<cl\xE9>" existe, 2-d\xE9velopper le \csname pour
-% avoir la <valeur>
- {\expandafter\expandafter\expandafter\skv_stop\csname skv_[#1]_\skv_removeextremespaces{#2}\endcsname}
-% Sinon, message d'erreur
- {\skv_stop\errmessage{Key "\skv_removeextremespaces{#2}" not defined}}%
- }%
+\let\useKVdefault\restoreKV
+%##########################################
+%############## Macro \useKV ##############
+%##########################################
+\def\useKV[#1]#2{\expanded{\skv_stripsp{\useKV_i[#1]}{#2}}}
+\def\useKV_i[#1]#2{\expandafter\useKV_ii\csname skv_[#1]_#2\endcsname{#2}}
+\def\useKV_ii#1#2{%
+ \ifdefined#1\unexpanded\expandafter{#1}%
+ \else \errmessage{Key "#2" not defined}%
+ \fi
}
-
-% Voici une macro purement d\xE9veloppable qui teste si #2 (la <cl\xE9> du <trousseau>
-% #1) est \xE9gale \xE0 "true" ou \xE0 "false" et selon l'issue, ex\xE9cute le 1er ou 2e
-% argument qui suit (arguments appel\xE9s <vrai> et <faux>)
-\def\ifboolKV[#1]#2{%
-% Cette macro donnera un des 2 arguments <vrai> ou <faux> en _2_ d\xE9veloppements
-% gr\xE2ce au \romannumeral
- \romannumeral\skv_ifempty{#2}
-% Si la <cl\xE9> est vide, message d'erreur
- {\skv_stop\errmessage{Key name missing}\skv_second}
- {\skv_ifcsname{skv_[#1]_\skv_removeextremespaces{#2}}
-% Si la <cl\xE9> d\xE9barrass\xE9e de ses espaces extr\xEAmes existe, tester son contenu
- {\skv_eearg\ifboolKV_i{\csname skv_[#1]_\skv_removeextremespaces{#2}\endcsname}}
-% Sinon, message d'erreur
- {\skv_stop\errmessage{Key "\skv_removeextremespaces{#2}" not defined}\skv_second}%
+%##########################################
+%############# Macros de test #############
+%##########################################
+\def\ifboolKV[#1]#2{\romannumeral\skv_stripsp{\ifboolKV_i[#1]}{#2}}
+\def\ifboolKV_i[#1]#2{%
+ \skv_ifempty{#2}
+ {\skv_stop\errmessage{Empty argument is not a valid boolean}\skv_second
+ }
+ {\skv_ifcsname{skv_[#1]_#2}
+ {\skv_eearg\ifboolKV_ii{\csname skv_[#1]_#2\endcsname}}
+ {\skv_stop\errmessage{Key "#2" not defined}\skv_second}%
}%
}
-
-% Cette macro teste si #1, qui est une <valeur>, vaut "true" ou "false"
-\def\ifboolKV_i#1{%
-% Tester d'abord si elle vaut "true"
+\def\ifboolKV_ii#1{%% Cette macro teste si #1, qui est une <valeur>, vaut "true" ou "false"
\skv_ifargtrue{#1}
- {\expandafter\skv_stop\skv_first}
+ {\expandafter\skv_stop\skv_first
+ }
{\skv_ifargfalse{#1}
-% Puis si elle vaut "false"
{\expandafter\skv_stop\skv_second}
-% Si ni l'un ni l'autre, la <valeur> n'est pas un bool\xE9en acceptable
{\skv_stop\errmessage{Value "#1" is not a valid boolean}\skv_second}%
}%
}
-% La macro \skv_ifargtrue{<argument>} teste de fa\xE7on purement d\xE9veloppable si
-% <argument> vaut "true" ou "false".
-% Pour cela, on transmet \xE0 \skv_ifargtrue_i l'argument "<argument>true" qui est
-% d\xE9limit\xE9 par \_nil
+\def\testboolKV#1{\romannumeral\skv_stripsp{\testboolKV_i}{#1}}% macro publique qui teste si #1 est <true> ou <false>, erreur sinon
+\def\testboolKV_i#1{%
+ \skv_ifempty{#1}
+ {\skv_stop\errmessage{Empty argument is not a valid boolean}\skv_second}
+ {\skv_stripsp{\ifboolKV_ii}{#1}}%
+}
+
\def\skv_ifargtrue#1{\skv_ifargtrue_i#1true\_nil}
-% Dans la macro \skv_ifargtrue_i, l'argument #1 est ce qui se trouve avant
-% "true" dans "<argument>true" :
-% - s'il n'est pas vide, s\xE9lectionner l'argument <faux>
-% - s'il est vide, cela signifie que <argument> commence par "true" ; il est
-% donc de la forme "true<autre>"
-% L'argument #2 est ce qui se trouve apr\xE8s "true" dans "true<autre>true",
-% c'est donc "<autre>true".
-% Pour \xEAtre s\xFBr que <autre> est <vide>, on transmet "<autre>true" \xE0
-% \skv_ifargtrue_ii qui teste si la r\xE9union de ce qui est avant le
-% premier "true" et ce qui est apr\xE8s est <vide>
\def\skv_ifargtrue_i#1true#2\_nil{\skv_ifempty{#1}{\skv_ifargtrue_ii#2\_nil}\skv_second}
\def\skv_ifargtrue_ii#1true#2\_nil{\skv_ifempty{#1#2}}
-
-% On proc\xE8de de m\xEAme pour tester "false"
\def\skv_ifargfalse#1{\skv_ifargfalse_i#1false\_nil}
\def\skv_ifargfalse_i#1false#2\_nil{\skv_ifempty{#1}{\skv_ifargfalse_ii#2\_nil}\skv_second}
\def\skv_ifargfalse_ii#1false#2\_nil{\skv_ifempty{#1#2}}
-
-\def\showKV[#1]#2{%
-% Ecrire dans le fichier log "Key [<trousseau>]<cl\xE9>="
- \immediate\write-1 {Key [#1]\skv_removeextremespaces{#2}=%
- \skv_ifcsname{skv_[#1]_\skv_removeextremespaces{#2}}
-% si la <cl\xE9> est d\xE9finie, prendre le \meaning de la macro correspondante
- {\expandafter\expandafter\expandafter\skv_show\expandafter
- \meaning\csname skv_[#1]_\skv_removeextremespaces{#2}\endcsname}
-% Sinon, afficher
- {not defined}%
- }%
+%##########################################
+%############# Macro \showKV ##############
+%##########################################
+\def\showKV[#1]#2{\expanded{\skv_stripsp{\showKV_i[#1]}{#2}}}
+\def\showKV_i[#1]#2{%
+ \immediate\write-1 {%
+ ^^JKey\space\space[#1]#2=%
+ \skv_ifcsname{skv_[#1]_#2}
+ {\expandafter\expandafter\expandafter\skv_show\expandafter
+ \meaning\csname skv_[#1]_#2\endcsname
+ \skv_ifcsname{skvcode_[#1]_#2}
+ {^^JCode [#1]#2=\expandafter\expandafter\expandafter\skv_show\expandafter
+ \meaning\csname skvcode_[#1]_#2\endcsname
+ }
+ {}%
+ }
+ {not defined%
+ }%
+ ^^J\relax}%
}
-% Mange ce qui se trouve jusqu'\xE0 "->" dans le d\xE9veloppement de \meaning
\def\skv_show#1->{}
\skv_restorecatcode
\endinput
@@ -327,3 +199,7 @@
|-----------------------------------------------------------------------------|
| 0.1 | 08/08/2017 | Premi\xE8re version |
|-----------------------------------------------------------------------------|
+| 0.2 | 27/04/2020 | - Un <code> peut \xEAtre assign\xE9 \xE0 une <cl\xE9> |
+| | | - Correction de bugs |
+| | | - Optimisations |
+|-----------------------------------------------------------------------------|
\ No newline at end of file
More information about the tex-live-commits
mailing list.