% \iffalse meta-comment
%
% File: expkv.dtx Copyright (C) 2020-2024 Jonathan P. Spratte
%
% This work may be distributed and/or modified under the conditions of the
% LaTeX Project Public License (LPPL), either version 1.3c of this license or
% (at your option) any later version. The latest version of this license is in
% the file:
%
% http://www.latex-project.org/lppl.txt
%
% ------------------------------------------------------------------------------
%
%<*driver>^^A>>=
\def\expkvDocNoGenerate{}
\input expkv-bundle.ins
\generate{\file{expkv.sty}{\from{expkv.dtx}{pkg}}}
\generate{\file{expkv.tex}{\from{expkv.dtx}{tex}}}
\generate{\file{t-expkv.tex}{\from{expkv.dtx}{ctx}}}
\endbatchfile
%</driver>^^A=<<
% \fi
%
% \section{\expkv}
%^^A the LaTeX package >>=
% \subsection{The \LaTeX\ Package}
% First we set up the \LaTeX\ package. That one doesn't really do much except
% |\input|ting the generic code and identifying itself as a package. Additional
% an |all| option is declared to load all the sub modules in one go.
% \gobbledocstriptag
%<*pkg>
% \begin{macrocode}
\def\ekv@tmp
{%
\ProvidesFile{expkv.tex}%
[\ekvDate\space v\ekvVersion\space an expandable key=val implementation]%
}
\input{expkv.tex}
\ProvidesPackage{expkv}%
[\ekvDate\space v\ekvVersion\space an expandable key=val implementation]
\let\ekv@tmp\@empty
\DeclareOption{all}
{%
\def\ekv@tmp
{\RequirePackage{expkv-pop,expkv-cs,expkv-def,expkv-opt}}%
}
\ProcessOptions\relax
\ekv@tmp
% \end{macrocode}
% \gobbledocstriptag
%</pkg>
%^^A=<<
%^^A the ConTeXt module >>=
% \subsection{The \ConTeXt\ module}
% This is pretty straight forward, we just have to change the error throwing
% mechanism for \ConTeXt\ (the approach taken for plain and \LaTeX\ breaks in
% \ConTeXt, effectively breaking \ConTeXt, dropping you in an interactive \TeX\
% session with almost no means of escape).
% \gobbledocstriptag
%<*ctx>
% \begin{macrocode}
\writestatus{loading}{ConTeXt User Module / expkv}
\unprotect
\input expkv.tex
\long\def\ekv@err@collect#1\par#2%
{\directlua{tex.error[[\detokenize{#2} Error: #1]]}}
\writestatus{loading}
{ConTeXt User Module / expkv / Version \ekvVersion\space loaded}
\protect\endinput
% \end{macrocode}
% \gobbledocstriptag
%</ctx>
%^^A=<<
%^^A main file >>=
% \subsection{The Generic Code}
% The rest of this implementation will be the generic code.
% \gobbledocstriptag
%<*tex>
%
% We make sure that it's only input once:
% \begin{macrocode}
\expandafter\ifx\csname ekvVersion\endcsname\relax
\else
\expandafter\endinput
\fi
% \end{macrocode}
%
% Check whether \eTeX\ and |\expanded| are available -- \expkv\ requires \eTeX.
% \begin{macrocode}
\begingroup
\edef\ekvtmpa{\string\expanded}
\edef\ekvtmpb{\meaning\expanded}
\expandafter
\endgroup
\ifx\ekvtmpa\ekvtmpb
\expandafter\let\csname ekv@expanded\endcsname\expanded
\expandafter\let\csname ekv@unexpanded\endcsname\unexpanded
\else
\begingroup
\edef\ekvtmpa{\string\expanded}
\edef\ekvtmpb{\meaning\normalexpanded}
\expandafter
\endgroup
\ifx\ekvtmpa\ekvtmpb
\expandafter\let\csname ekv@expanded\endcsname\normalexpanded
\expandafter\let\csname ekv@unexpanded\endcsname\normalunexpanded
\else
\errmessage
{expkv Error: e-TeX and the \noexpand\expanded primitive required}%
\expandafter\endinput
\fi
\fi
% \end{macrocode}
%
% \begin{macro}{\ekvVersion,\ekvDate}
% We're on our first input, so lets store the version and date in a macro.
% \begin{macrocode}
\def\ekvVersion{2.1}
\def\ekvDate{2024-12-26}
% \end{macrocode}
% \end{macro}
%
% If the \LaTeX\ format is loaded we want to be a good file and report back who
% we are, for this the package will have defined |\ekv@tmp| to use
% |\ProvidesFile|, else this will expand to a |\relax| and do no harm.
% \begin{macrocode}
\csname ekv@tmp\endcsname
% \end{macrocode}
%
% Store the category code of |@| to later be able to reset it and change it to
% 11 for now.
% \begin{macrocode}
\expandafter\chardef\csname ekv@tmp\endcsname=\catcode`\@
\catcode`\@=11
% \end{macrocode}
% |\ekv@tmp| might later be reused to gobble any prefixes which might be
% provided to |\ekvdef| and similar in case the names are invalid, we just
% temporarily use it here as means to store the current category code of |@| to
% restore it at the end of the file, we never care for the actual definition of
% it.
%
% \begin{macro}[internal]{\ekv@if@lastnamedcs}
% If the primitive |\lastnamedcs| is available, we can be a bit faster than
% without it. So we test for this and save the test's result in this macro.
% \begin{macrocode}
\begingroup
\edef\ekv@tmpa{\string \lastnamedcs}
\edef\ekv@tmpb{\meaning\lastnamedcs}
\ifx\ekv@tmpa\ekv@tmpb
\def\ekv@if@lastnamedcs{\long\def\ekv@if@lastnamedcs##1##2{##1}}
\else
\def\ekv@if@lastnamedcs{\long\def\ekv@if@lastnamedcs##1##2{##2}}
\fi
\expandafter
\endgroup
\ekv@if@lastnamedcs
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@empty}
% Sometimes we have to introduce a token to prevent accidental brace stripping.
% This token would then need to be removed by |\@gobble| or similar. Instead we
% can use |\ekv@empty| which will just expand to nothing, that is faster than
% gobbling an argument.
% \begin{macrocode}
\def\ekv@empty{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \@gobble,\@gobbletwo,\@gobblethree,
% \@firstofone,\@firstoftwo,\@secondoftwo,
% \ekv@fi@gobble,\ekv@fi@firstofone,\ekv@fi@firstoftwo,\ekv@fi@secondoftwo,
% \ekv@gobble@mark,\ekv@gobbleto@stop,\ekv@gobble@from@mark@to@stop
% }
% Since branching tests are often more versatile than |\if...\else...\fi|
% constructs, we define helpers that are branching pretty fast. Also here are
% some other utility functions that just grab some tokens. The ones that are
% also contained in \LaTeX\ don't use the |ekv| prefix. Not all of the ones
% defined here are really needed by \expkv\ but are provided because packages
% like \expkvd\ or \expkvo\ need them (and I don't want to define them in each
% package which might need them).
% \begin{macrocode}
\long\def\@gobble#1{}
\long\def\@gobbletwo#1#2{}
\long\def\@gobblethree#1#2#3{}
\long\def\@firstofone#1{#1}
\long\def\@firstoftwo#1#2{#1}
\long\def\@secondoftwo#1#2{#2}
\long\def\ekv@fi@gobble\fi\@firstofone#1{\fi}
\long\def\ekv@fi@firstofone\fi\@gobble#1{\fi#1}
\long\def\ekv@fi@firstoftwo\fi\@secondoftwo#1#2{\fi#1}
\long\def\ekv@fi@secondoftwo\fi\@firstoftwo#1#2{\fi#2}
\def\ekv@gobble@mark\ekv@mark{}
\long\def\ekv@gobbleto@stop#1\ekv@stop{}
\long\def\ekv@gobble@from@mark@to@stop\ekv@mark#1\ekv@stop{}
% \end{macrocode}
% \end{macro}
% As you can see |\ekv@gobbleto@stop| uses a special marker |\ekv@stop|. The
% package will use three such markers, the one you've seen already, |\ekv@mark|
% and |\ekv@nil|. Contrarily to how for instance \pkg{expl3} does things, we
% don't define them, as we don't need them to have an actual meaning. This has
% the advantage that if they somehow get expanded -- which should never happen
% if things work out -- they'll throw an error directly.
%
% \begin{macro}[internal]
% {
% \ekv@ifempty,\ekv@ifempty@,\ekv@ifempty@true,\ekv@ifempty@false,
% \ekv@ifempty@true@F,\ekv@ifempty@true@F@gobble,
% \ekv@ifempty@true@F@gobbletwo
% }
% We can test for a lot of things building on an if-empty test, so lets define a
% really fast one. Since some tests might have reversed logic (true if something
% is not empty) we also set up macros for the reversed branches.
% \begin{macrocode}
\long\def\ekv@ifempty#1%
{%
\ekv@ifempty@\ekv@ifempty@A#1\ekv@ifempty@B\ekv@ifempty@true
\ekv@ifempty@A\ekv@ifempty@B\@secondoftwo
}
\long\def\ekv@ifempty@#1\ekv@ifempty@A\ekv@ifempty@B{}
\long\def\ekv@ifempty@true\ekv@ifempty@A\ekv@ifempty@B\@secondoftwo#1#2{#1}
\long\def\ekv@ifempty@false\ekv@ifempty@A\ekv@ifempty@B\@firstoftwo#1#2{#2}
\long\def\ekv@ifempty@true@F\ekv@ifempty@A\ekv@ifempty@B\@firstofone#1{}
\long\def\ekv@ifempty@true@F@gobble\ekv@ifempty@A\ekv@ifempty@B\@firstofone#1#2%
{}
\long\def\ekv@ifempty@true@F@gobbletwo
\ekv@ifempty@A\ekv@ifempty@B\@firstofone#1#2#3%
{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {\ekv@ifblank,\ekv@ifblank@,\ekv@ifblank@false,\ekv@ifblank@gobbletrue}
% The obvious test that can be based on an if-empty is if-blank, meaning a test
% checking whether the argument is empty or consists only of spaces. But instead
% of building atop |\ekv@ifempty| our version will utilise the fact that the
% argument in none of our usages can contain |\ekv@stop| (due to the way we
% check for end-of-list), and hence we can use an even faster check. This here
% works due to the fact that \TeX\ will read at least one token (or a group) for
% an undelimited parameter which might be the end marker of the delimited next
% parameter. So if |#1| to |\ekv@ifblank| is indeed blank, |#1| of
% |\ekv@ifblank@| will be the placed |\ekv@stop| and |#2| will be anything until
% the next |\ekv@stop|. The wrapper |\ekv@ifblank| will not be used by \expkv\
% for speed reasons but \expkvo\ uses it. Also, not only a |TF| variant is
% provided but also a rather strange one that assumes that only the |F| branch
% is provided and that this branch consists only of a single token.
% \begin{macrocode}
\long\def\ekv@ifblank#1%
{\ekv@ifblank@#1\ekv@stop\ekv@ifblank@false\ekv@stop\@firstoftwo}
\long\def\ekv@ifblank@\ekv@mark#1#2\ekv@stop{}
\long\def\ekv@ifblank@false\ekv@stop\@firstoftwo#1#2{#2}
\def\ekv@ifblank@gobbletrue\ekv@stop#1{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@ifatmostone}
% Our check for at most one group or single non-space token is rather straight
% forward. There are in essence three cases.
%
% If |#1| is blank the auxiliary |\ekv@ifatmostone@| will read
% |\ekv@stop|\hspace{0pt}|\ekv@iflabk@false| as |#1#2| and |#3| will be empty.
% Leading to the test being true.
%
% If |#1| has exactly one group or single non-space token the auxiliary will
% read that argument plus |\ekv@stop| as |#1#2| and |\ekv@ifblank@false| as
% |#3|. Leading to the test being true.
%
% If |#1| has two or more normal arguments the auxiliary will gobble the first
% two as |#1#2| and the possibly empty remainder until the first |\ekv@stop|
% as |#3|. Then |\ekv@ifblank@false| kicks in and the test is indeed false.
% \begin{macrocode}
\long\def\ekv@ifatmostone#1%
{\ekv@ifatmostone@#1\ekv@stop\ekv@ifblank@false\ekv@stop\@firstoftwo}
\long\def\ekv@ifatmostone@#1#2#3\ekv@stop{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@ifdefined}
% We'll need to check whether something is defined quite frequently, so why not
% define a macro that does this. The following test is expandable and pretty
% fast. The version with |\lastnamedcs| is the fastest version to test for an
% undefined macro I know of (that considers both undefined macros and those with
% the meaning |\relax|).
% \begin{macrocode}
\ekv@if@lastnamedcs
{%
\long\def\ekv@ifdefined#1{\ifcsname#1\endcsname\ekv@ifdef@\fi\@secondoftwo}
\def\ekv@ifdef@\fi\@secondoftwo
{%
\fi
\expandafter\ifx\lastnamedcs\relax
\ekv@fi@secondoftwo
\fi
\@firstoftwo
}
}
{%
\long\def\ekv@ifdefined#1%
{%
\ifcsname#1\endcsname\ekv@ifdef@\fi\ekv@ifdef@false#1\endcsname\relax
\ekv@fi@secondoftwo
\fi
\@firstoftwo
}
\def\ekv@ifdef@\fi\ekv@ifdef@false{\fi\expandafter\ifx\csname}
\long\def\ekv@ifdef@false
#1\endcsname\relax\ekv@fi@secondoftwo\fi\@firstoftwo#2#3%
{#3}
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@strip,\ekv@strip@a,\ekv@strip@b,\ekv@strip@c}
% We borrow some ideas of \pkg{expl3}'s \pkg{l3tl} to strip spaces
% from keys and values. This |\ekv@strip| also strips one level of outer braces
% \emph{after} stripping spaces, so an input of | {abc} | becomes |abc| after
% stripping. It should be used with |#1| prefixed by |\ekv@mark|. Also this
% implementation at most strips \emph{one} space from both sides (which should
% be fine most of the time, since \TeX\ reads consecutive spaces as a single one
% during tokenisation).
% \begin{macrocode}
\def\ekv@strip#1%
{%
\long\def\ekv@strip##1%
{%
\ekv@strip@a
##1\ekv@nil
\ekv@mark#1%
#1\ekv@nil
}%
\long\def\ekv@strip@a##1\ekv@mark#1{\ekv@strip@b##1\ekv@mark}%
}
\ekv@strip{ }
\long\def\ekv@strip@b#1 \ekv@nil{\ekv@strip@c#1\ekv@nil}
\long\def\ekv@strip@c\ekv@mark#1\ekv@nil\ekv@mark#2\ekv@nil#3{#3{#1}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {\ekv@strip@key,\ekv@strip@key@a,\ekv@strip@key@b,\ekv@strip@key@c}
% Same idea and code as |\ekv@strip|, but the second argument to
% |\ekv@strip@key| must be a single token and the result of the stripping will
% be |\detokenize|d.
% \begin{macrocode}
\def\ekv@strip@key#1%
{%
\long\def\ekv@strip@key##1{\ekv@strip@key@a##1\ekv@nil\ekv@mark#1#1\ekv@nil}
\long\def\ekv@strip@key@a##1\ekv@mark#1{\ekv@strip@key@b##1\ekv@mark}
}
\ekv@strip@key{ }
\long\def\ekv@strip@key@b#1 \ekv@nil{\ekv@strip@key@c#1\ekv@nil}
\long\def\ekv@strip@key@c\ekv@mark#1\ekv@nil\ekv@mark#2\ekv@nil#3%
{\expandafter#3\detokenize{#1}\ekv@mark{#1}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \ekv@exparg,\ekv@exparg@,
% \ekv@expandedarg,\ekv@fexparg,\ekv@expandafter
% \ekv@expargtwice,\ekv@expargtwice@,\ekv@zero
% }
% To reduce some code doublets while gaining some speed (and also as convenience
% for other packages in the family), it is often useful to expand the first
% token in a definition once. Let's define a wrapper for this. And while we're
% at it, also define a helper for |f|-~and |e|-expansion as well.
%
% Also, to end a |\romannumeral| expansion, we want to use |\z@|, which is
% contained in both plain \TeX\ and \LaTeX, but we use a private name for it to
% make it easier to spot and hence easier to manage.
% \begin{macrocode}
\let\ekv@zero\z@
\long\def\ekv@exparg#1#2%
{\ekv@expanded{\ekv@unexpanded{#1}\expandafter}\expandafter{#2}}
\long\def\ekv@expandafter#1{\ekv@expanded{\ekv@unexpanded{#1}\expandafter}}
\long\def\ekv@exparg@#1#2{#2{#1}}%
\long\def\ekv@expandedarg#1#2{\ekv@expanded{\ekv@unexpanded{#1}{#2}}}
\long\def\ekv@fexparg#1#2%
{%
\ekv@expanded{\ekv@unexpanded{#1}\expandafter}\expandafter
{\romannumeral`\^^@#2}%
}
\long\def\ekv@expargtwice#1#2{\expandafter\ekv@expargtwice@\expandafter{#2}{#1}}
\def\ekv@expargtwice@{\expandafter\ekv@exparg@\expandafter}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvcsvloop}
% \begin{macro}[internal]{\ekv@csv@loop@active,\ekv@csv@loop@active@end}
% An |\ekvcsvloop| will just loop over a csv list in a simple manner. First we
% split at active commas (gives better performance this way), next we have to
% check whether we're at the end of the list (checking for |\ekv@stop|). If
% not we go on splitting at commas of category other.
% \begin{macrocode}
\begingroup
\def\ekvcsvloop#1{%
\endgroup
\long\def\ekvcsvloop##1##2%
{\ekv@csv@loop@active{##1}\ekv@mark##2#1\ekv@stop#1}
% \end{macrocode}
% This does the same as |\ekv@csv@loop| but for active commas.
% \begin{macrocode}
\long\def\ekv@csv@loop@active##1##2#1%
{%
\ekv@gobble@from@mark@to@stop##2\ekv@csv@loop@active@end\ekv@stop
\ekv@csv@loop{##1}##2,\ekv@stop,%
}%
\long\def\ekv@csv@loop@active@end
\ekv@stop
\ekv@csv@loop##1\ekv@mark\ekv@stop,\ekv@stop,%
{}%
}
% \end{macrocode}
% Do the definitions with the weird catcode.
% \begin{macrocode}
\catcode`\,=13
\ekvcsvloop,
% \end{macrocode}
% \end{macro}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@csv@loop,\ekv@csv@loop@do,\ekv@csv@loop@end}
% We use temporary macros and an |\expandafter| chain to preexpand
% |\ekv@strip| here. After splitting at other commas we check again for end
% the end of the sublist, check for blank elements which should be ignored,
% and else strip spaces and execute the user code (protecting it from further
% expanding with |\unexpanded|).
% \begin{macrocode}
\def\ekv@csv@loop#1%
{%
\long\def\ekv@csv@loop##1##2,%
{%
\ekv@gobble@from@mark@to@stop##2\ekv@csv@loop@end\ekv@stop
\ekv@ifblank@##2\ekv@stop\ekv@ifblank@gobbletrue
\ekv@stop\ekv@csv@loop@blank
#1\ekv@csv@loop@do{##1}%
}%
}
\expandafter\ekv@csv@loop\expandafter{\ekv@strip{#2}}
\long\def\ekv@csv@loop@do#1#2{\ekv@unexpanded{#2{#1}}\ekv@csv@loop{#2}\ekv@mark}
\def\ekv@csv@loop@end#1%
{%
\long\def\ekv@csv@loop@end
\ekv@stop
\ekv@ifblank@\ekv@mark\ekv@stop\ekv@stop\ekv@ifblank@gobbletrue
\ekv@stop\ekv@csv@loop@blank
#1\ekv@csv@loop@do##1%
{\ekv@csv@loop@active{##1}\ekv@mark}%
}
\expandafter\ekv@csv@loop@end\expandafter{\ekv@strip{\ekv@mark\ekv@stop}}
\long\expandafter\def\expandafter\ekv@csv@loop@blank
\ekv@strip{\ekv@mark#1}\ekv@csv@loop@do#2%
{\ekv@csv@loop{#2}\ekv@mark}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekv@name,\ekv@name@set,\ekv@name@key}
% The keys will all follow the same naming scheme, so we define it here.
% \begin{macrocode}
\def\ekv@name@set#1{ekv#1(}
\long\def\ekv@name@key#1{#1)}
\long\ekv@expandedarg{\def\ekv@name#1#2}%
{%
\ekv@unexpanded\expandafter{\ekv@name@set{#1}}%
\ekv@unexpanded\expandafter{\ekv@name@key{\detokenize{#2}}}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@undefined@set}
% We can misuse the macro name we use to expandably store the set-name in a
% single token -- since this increases performance drastically, especially for
% long set-names -- to throw a more meaningful error message in case a set isn't
% defined. The name of |\ekv@undefined@set| is a little bit misleading, as it is
% called in either case inside of |\csname|, but the result will be a control
% sequence with meaning |\relax| if the set is undefined, hence will break the
% |\csname| building the key-macro which will throw the error message.
% \begin{macrocode}
\def\ekv@undefined@set#1{! expkv Error: Set `#1' undefined.}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@checkvalid}
% We place some restrictions on the allowed names, though, namely sets and
% keys are not allowed to be empty -- blanks are fine (meaning \mbox{set-
% or} key-names consisting of spaces). The |\def\ekv@tmp| gobbles any \TeX\
% prefixes which would otherwise throw errors. This will, however, break the
% package if an |\outer| has been gobbled this way. I consider that good,
% because keys shouldn't be defined |\outer| anyways.
% \begin{macrocode}
\protected\ekv@expandedarg{\def\ekv@checkvalid#1#2}%
{%
\ekv@unexpanded\expandafter{\ekv@ifempty{#1}}%
\ekv@unexpanded
{{%
\def\ekv@tmp{}%
\ekv@errm{empty set name not allowed}%
}}%
{%
\ekv@unexpanded\expandafter{\ekv@ifempty{#2}}%
\ekv@unexpanded
{%
{%
\def\ekv@tmp{}%
\ekv@errm{empty key name not allowed}%
}%
\@secondoftwo
}%
}%
\ekv@unexpanded{\@gobble}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvifdefined,\ekvifdefinedNoVal}
% And provide user-level macros to test whether a key is defined.
% \begin{macrocode}
\ekv@expargtwice{\long\def\ekvifdefined#1#2}%
{\expandafter\ekv@ifdefined\expandafter{\ekv@name{#1}{#2}}}
\ekv@expargtwice{\long\def\ekvifdefinedNoVal#1#2}%
{\expandafter\ekv@ifdefined\expandafter{\ekv@name{#1}{#2}N}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}
% {
% \ekvdef,\ekvdefNoVal,\ekvlet,\ekvletNoVal,\ekvletkv,\ekvletkvNoVal,
% \ekvdefunknown,\ekvdefunknownNoVal,\ekvletunknown,\ekvletunknownNoVal
% }
% Set up the key defining macros |\ekvdef| etc. We use temporary macros to set
% these up with a few expansions already done.
% \begin{macrocode}
\def\ekvdef#1#2#3#4#5#6%
{%
\protected\long\def\ekvdef##1##2##3%
{#1{\expandafter\def\csname#2\endcsname####1{##3}#4}}%
\protected\long\def\ekvdefNoVal##1##2##3%
{#1{\expandafter\def\csname#2N\endcsname{##3}#4}}%
\protected\long\def\ekvlet##1##2##3%
{#1{\expandafter\let\csname#2\endcsname##3#4}}%
\protected\long\def\ekvletNoVal##1##2##3%
{#1{\expandafter\let\csname#2N\endcsname##3#4}}%
\ekv@expargtwice{\protected\long\def\ekv@defunknown##1##2##3##4}%
{%
\romannumeral
\ekv@exparg
{\ekv@zero\ekv@checkvalid{##3}.}%
{%
\expandafter\expandafter\expandafter
\def\expandafter\csname\ekv@name{##3}{}u##1\endcsname##2{##4}%
#6%
}%
}%
\ekv@expargtwice{\protected\long\def\ekv@letunknown##1##2##3}%
{%
\romannumeral
\ekv@exparg
{\ekv@zero\ekv@checkvalid{##2}.}%
{%
\expandafter\expandafter\expandafter
\let\expandafter\csname\ekv@name{##2}{}u##1\endcsname##3%
#5%
}%
}%
\protected\long\def\ekvletkv##1##2##3##4%
{%
#1%
{%
\expandafter\let\csname#2\expandafter\endcsname
\csname#3\endcsname
#4%
}%
}%
\protected\long\def\ekvletkvNoVal##1##2##3##4%
{%
#1%
{%
\expandafter\let\csname#2N\expandafter\endcsname
\csname#3N\endcsname
#4%
}%
}%
}
\edef\ekvdefNoVal
{%
{\ekv@unexpanded\expandafter{\ekv@checkvalid{#1}{#2}}}%
{\ekv@unexpanded\expandafter{\ekv@name{#1}{#2}}}%
{\ekv@unexpanded\expandafter{\ekv@name{#3}{#4}}}%
{%
\ekv@unexpanded{\expandafter\ekv@defsetmacro\csname}%
\ekv@unexpanded\expandafter{\ekv@undefined@set{#1}\endcsname{#1}}%
}%
{%
\ekv@unexpanded{\expandafter\ekv@defsetmacro\csname}%
\ekv@unexpanded\expandafter{\ekv@undefined@set{#2}\endcsname{#2}}%
}%
{%
\ekv@unexpanded{\expandafter\ekv@defsetmacro\csname}%
\ekv@unexpanded\expandafter{\ekv@undefined@set{#3}\endcsname{#3}}%
}%
}
\expandafter\ekvdef\ekvdefNoVal
\ekv@exparg{\protected\long\def\ekvdefunknown#1#2}%
{\ekv@defunknown{}{##1##2##3}{#1}{#2}}
\ekv@exparg{\protected\long\def\ekvdefunknownNoVal#1#2}%
{\ekv@defunknown{N}{##1##2}{#1}{#2}}
\ekv@exparg{\protected\long\def\ekvletunknown#1#2}%
{\ekv@letunknown{}{#1}{#2}}
\ekv@exparg{\protected\long\def\ekvletunknownNoVal#1#2}%
{\ekv@letunknown{N}{#1}{#2}}
\let\ekv@defunknown\ekv@undefined
\let\ekv@letunknown\ekv@undefined
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvredirectunknown,\ekvredirectunknownNoVal}
% \begin{macro}[internal]
% {
% \ekv@defredirectunknown,\ekv@redirectunknown@aux,
% \ekv@redirectunknownNoVal@aux
% }
% The redirection macros prepare the unknown function by looping over the
% provided list of sets and leaving a |\ekv@redirect@kv| or |\ekv@redirect@k|
% for each set. Only the first of these internals will receive the \key\ and
% \val\ as arguments.
% \begin{macrocode}
\protected\def\ekv@defredirectunknown#1#2#3#4#5#6%
{%
\begingroup
\edef\ekv@tmp
{%
\ekvcsvloop#1{#6}%
\ekv@unexpanded{#2}%
{\ekvcsvloop{}{#5,#6}}%
}%
\ekv@expargtwice
{\endgroup\long#3{#5}}%
{\expandafter#4\ekv@tmp\ekv@stop}%
}
\ekv@exparg{\protected\def\ekvredirectunknown#1#2}%
{%
\ekv@defredirectunknown
\ekv@redirect@kv
\ekv@err@redirect@kv@notfound
\ekvdefunknown
\ekv@redirectunknown@aux
{#1}{#2}%
}
\ekv@exparg{\protected\def\ekvredirectunknownNoVal#1#2}%
{%
\ekv@defredirectunknown
\ekv@redirect@k
\ekv@err@redirect@k@notfound
\ekvdefunknownNoVal
\ekv@redirectunknownNoVal@aux
{#1}{#2}%
}
\def\ekv@redirectunknown@aux#1{#1{##1}{##2}}
\def\ekv@redirectunknownNoVal@aux#1{#1{##1}}
\let\ekv@defredirectunknown\ekv@undefined
% \end{macrocode}
% \end{macro}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \ekv@redirect@k,\ekv@redirect@k@a,\ekv@redirect@k@a@,
% \ekv@redirect@k@b,\ekv@redirect@k@c,\ekv@redirect@k@d,
% \ekv@redirect@kv,\ekv@redirect@kv@a,\ekv@redirect@kv@a@,
% \ekv@redirect@kv@b,\ekv@redirect@kv@c,\ekv@redirect@kv@d
% }
% The redirect code works by some simple loop over all the sets, which we
% already preprocessed in |\ekv@defredirectunknown|. For some optimisation we
% blow this up a bit code wise, essentially, all this does is |\ekvifdefined|
% or |\ekvifdefinedNoVal| in each set, if there is a match gobble the
% remainder of the specified sets and execute the key macro, else go on with
% the next set (to which the \key\ and \val\ are forwarded).
%
% First we set up some code which is different depending on |\lastnamedcs|
% being available or not. All this is stored in a temporary macro to have
% pre-expanded |\ekv@name| constellations ready.
% \begin{macrocode}
\def\ekv@redirect@k#1#2#3#4%
{%
\ekv@if@lastnamedcs
{%
\def\ekv@redirect@k##1##2##3%
{%
\ifcsname#1\endcsname\ekv@redirect@k@a\fi
##3{##1}%
}%
\def\ekv@redirect@k@a\fi{\fi\expandafter\ekv@redirect@k@b\lastnamedcs}%
\long\def\ekv@redirect@kv##1##2##3##4%
{%
\ifcsname#2\endcsname\ekv@redirect@kv@a\fi\@gobble{##1}%
##4{##1}{##2}%
}%
\def\ekv@redirect@kv@a\fi\@gobble
{\fi\expandafter\ekv@redirect@kv@b\lastnamedcs}%
}
{%
\def\ekv@redirect@k##1##2##3%
{%
\ifcsname#1\endcsname\ekv@redirect@k@a\fi\ekv@redirect@k@a@
#1\endcsname
##3{##1}%
}%
\def\ekv@redirect@k@a@#3\endcsname{}%
\def\ekv@redirect@k@a\fi\ekv@redirect@k@a@
{\fi\expandafter\ekv@redirect@k@b\csname}%
\long\def\ekv@redirect@kv##1##2##3##4%
{%
\ifcsname#2\endcsname\ekv@redirect@kv@a\fi\ekv@redirect@kv@a@
#2\endcsname{##1}%
##4{##1}{##2}%
}%
\long\def\ekv@redirect@kv@a@#4\endcsname##3{}%
\def\ekv@redirect@kv@a\fi\ekv@redirect@kv@a@
{\fi\expandafter\ekv@redirect@kv@b\csname}%
}%
}
% \end{macrocode}
% The key name given to this loop will already be |\detokenize|d by |\ekvset|,
% so we can safely remove the |\detokenize| here for some performance gain.
% \begin{macrocode}
\def\ekv@redirect@kv#1\detokenize#2#3\ekv@stop{\ekv@unexpanded{#1#2#3}}
\edef\ekv@redirect@kv
{%
{\expandafter\ekv@redirect@kv\ekv@name{#2}{#1}N\ekv@stop}%
{\expandafter\ekv@redirect@kv\ekv@name{#3}{#2}\ekv@stop}%
{\expandafter\ekv@redirect@kv\ekv@name{#1}{#2}N\ekv@stop}%
{\expandafter\ekv@redirect@kv\ekv@name{#1}{#2}\ekv@stop}%
}
% \end{macrocode}
% Everything is ready to make the real definitions.
% \begin{macrocode}
\expandafter\ekv@redirect@k\ekv@redirect@kv
% \end{macrocode}
% The remaining macros here are independent on |\lastnamedcs|, starting from
% the |@b| we know that there is a hash table entry, and get the macro as a
% parameter. We still have to test whether the macro is |\relax|, depending on
% the result of that test we have to either remove the remainder of the
% current test, or the remainder of the set list and invoke the macro.
% \begin{macrocode}
\def\ekv@redirect@k@b#1%
{\ifx\relax#1\ekv@redirect@k@c\fi\ekv@redirect@k@d#1}
\def\ekv@redirect@k@c\fi\ekv@redirect@k@d#1{\fi}
\def\ekv@redirect@k@d#1#2\ekv@stop{#1}
\def\ekv@redirect@kv@b#1%
{\ifx\relax#1\ekv@redirect@kv@c\fi\ekv@redirect@kv@d#1}
\long\def\ekv@redirect@kv@c\fi\ekv@redirect@kv@d#1#2{\fi}
\long\def\ekv@redirect@kv@d#1#2#3\ekv@stop{#1{#2}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@defsetmacro}
% In order to enhance the speed the set name given to |\ekvset| will be turned
% into a control sequence pretty early, so we have to define that control
% sequence.
% \begin{macrocode}
\edef\ekv@defsetmacro
{%
\ekv@unexpanded{\ifx#1\relax\edef#1##1}%
{%
\ekv@unexpanded\expandafter{\ekv@name@set{#2}}%
\ekv@unexpanded\expandafter{\ekv@name@key{##1}}%
}%
\ekv@unexpanded{\fi}%
}
\ekv@exparg{\protected\def\ekv@defsetmacro#1#2}{\ekv@defsetmacro}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvifdefinedset}
% \begin{macrocode}
\ekv@expargtwice{\def\ekvifdefinedset#1}%
{\expandafter\ekv@ifdefined\expandafter{\ekv@undefined@set{#1}}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@ifexp}
% We want to be able to include expansion control. This is started by a
% specific structure, namely if the stuff to the left of the equals sign
% contains a colon followed by a space followed by at least one non-space
% token. There is an additional rule namely the contents in front of the
% \verb*|: | marker mustn't contain spaces outside of braces, but
% unfortunately we can test this only after we did the real split and not as
% part of a fast test. The temporary meaning we set up here will get
% \tkn{:}{13}\vissp{ } and \tkn{:}{11}\vissp{ } as |#1| and |#2|.
%
% The real definition will take three arguments (two curried), namely the
% un-|\detokenize|d name as |#1|, what should be done if the \expnotation\
% should start as |#2|, and what should be done if no \expnotation\ is found
% as |#3|.
% \begin{macrocode}
\def\ekv@ifexp#1#2%
{%
% \end{macrocode}
% In the following explanations I use \tkn{:}{12}, \tkn{:}{13}, and
% \tkn{:}{11}, but I always mean that token followed by a space.
% \begin{macro}[internal]{\ekv@ifexp@split@o@or@other}
% \tkn{:}{12} splitter also used to test for \tkn{:}{13} and \tkn{:}{11}
% \begin{macrocode}
\long\def\ekv@ifexp@split@o@or@other
##1: ##2\ekv@stop##3%
##4#1##5\ekv@stop##6%
##7#2##8\ekv@stop##9%
{##9##6##3##1\ekv@stop##2}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]{\ekv@ifexp@split@a@or@l}
% \tkn{:}{13} splitter also used to test for \tkn{:}{11}
% \begin{macrocode}
\long\def\ekv@ifexp@split@a@or@l
##1#1##2\ekv@stop##3%
##4#2##5\ekv@stop##6%
{##6##3##1\ekv@stop##2}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {\ekv@ifexp@split@a,\ekv@ifexp@split@l}
% \tkn{:}{13} splitter
% \begin{macrocode}
\long\def\ekv@ifexp@split@a##1#1##2\ekv@stop##3%
{##3##1\ekv@stop##2}%
% \end{macrocode}
% \tkn{:}{11} splitter
% \begin{macrocode}
\long\def\ekv@ifexp@split@l##1#2##2\ekv@stop##3%
{##3##1\ekv@stop##2}%
% \end{macrocode}
% \end{macro}
% To get good performance in the most common case (standard category codes
% apply) we try to split on \tkn{:}{12}, due to the way this split works there
% are a few possible outcomes:
% \begin{enumerate}
% \item |\ekv@ifexp@none| is the first token if no colon was
% found at all
% \item |\ekv@ifexp@o| is the first token if only \tkn{:}{12}
% were part of \key
% \item |\ekv@ifexp@a| is put in front of either of the two
% aforementioned cases if there was at least one \tkn{:}{13} (in that case
% we don't yet know which was the first colon)
% \item |\ekv@ifexp@o| is put in front of any of the
% aforementioned cases if there was at least one \tkn{:}{11} (in which
% case we also don't know yet which was the first colon)
% \end{enumerate}
% \begin{macrocode}
\long\def\ekv@ifexp##1%
{%
\ekv@ifexp@split@o@or@other
##1\ekv@nil\ekv@stop\ekv@ifexp@o
: \ekv@stop\ekv@ifexp@none
##1\ekv@stop\ekv@ifexp@a#1\ekv@stop{}%
##1\ekv@stop\ekv@ifexp@l#2\ekv@stop{}%
}%
% \end{macrocode}
% \begin{macro}[internal]
% {\ekv@ifexp@o,\ekv@ifexp@none}
% If any of the next two are called we already know the outcome and can
% directly expand to it.
% \begin{macrocode}
\long\def\ekv@ifexp@o##1\ekv@stop
{\ekv@ifexp@done{##1}\ekv@mark}%
\long\def\ekv@ifexp@none
##1\ekv@nil\ekv@stop\ekv@ifexp@o\ekv@stop
##2##3%
{##3}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {\ekv@ifexp@a,\ekv@ifexp@a@i,\ekv@ifexp@a@ii}
% If this is called we know that there was no \tkn{:}{13}, if the first token
% now is |\ekv@ifexp@none| there was no \tkn{:}{12} as well
% \begin{macrocode}
\def\ekv@ifexp@a##1%
{%
\ekv@ifexp@a@i
##1\ekv@ifexp@a@ii
\ekv@ifexp@none\ekv@ifexp@a@or@o
}%
\def\ekv@ifexp@a@i##1\ekv@ifexp@none{}%
% \end{macrocode}
% Easy route, no \tkn{:}{12}, simply grab and pack
% \begin{macrocode}
\long\def\ekv@ifexp@a@ii
\ekv@ifexp@none\ekv@ifexp@a@or@o
##1#1##2\ekv@stop\ekv@ifexp@o\ekv@stop
{\ekv@ifexp@done{##1}\ekv@mark##2}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {
% \ekv@ifexp@a@or@o,
% \ekv@ifexp@a@not@o,\ekv@ifexp@a@not@o@,
% \ekv@ifexp@o@not@a
% }
% other route, there is a \tkn{:}{12}, re-split at \tkn{:}{13}
% \begin{macrocode}
\long\def\ekv@ifexp@a@or@o##1\ekv@stop
{%
\ekv@ifexp@split@a
##1\ekv@nil\ekv@stop\ekv@ifexp@a@not@o
#1\ekv@stop\ekv@ifexp@o@not@a
}%
% \end{macrocode}
% \tkn{:}{13} came earlier than \tkn{:}{12}
% \begin{macrocode}
\long\def\ekv@ifexp@a@not@o##1\ekv@stop
{\ekv@ifexp@a@not@o@{##1}\ekv@mark}
\long\def\ekv@ifexp@a@not@o@
##1##2\ekv@nil#1\ekv@stop\ekv@ifexp@o@not@a
{\ekv@ifexp@done{##1}##2: }%
% \end{macrocode}
% \tkn{:}{12} came earlier than \tkn{:}{13}
% \begin{macrocode}
\long\def\ekv@ifexp@o@not@a
##1\ekv@nil\ekv@stop\ekv@ifexp@a@not@o\ekv@stop
{\ekv@ifexp@done{##1}\ekv@mark}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]{\ekv@ifexp@l,\ekv@ifexp@l@i,\ekv@ifexp@l@ii}
% Now this is the most complicated case, if |\ekv@ifexp@l| is
% called there are a few possibilities:
% \begin{enumerate}
% \item |#1| is |\ekv@ifexp@none|: easiest route, only
% \tkn{:}{11} was there
% \item |#1| is |\ekv@ifexp@o|: complicated route, there was a
% \tkn{:}{11} and a \tkn{:}{12}
% \item |#1| is |\ekv@ifexp@a| and after that comes
% |\ekv@ifexp@none|: more complicated, there was a
% \tkn{:}{11} and a \tkn{:}{13}
% \item |#1| is |\ekv@ifexp@a| and after that comes
% |\ekv@ifexp@o|: cursed route, there were \tkn{:}{11},
% \tkn{:}{12}, and \tkn{:}{13}
% \end{enumerate}
% \begin{macrocode}
\def\ekv@ifexp@l##1%
{%
\ekv@ifexp@l@i
##1\ekv@ifexp@l@ii
\ekv@ifexp@none{}%
##1\ekv@ifexp@l@or@o
\ekv@ifexp@o
\ekv@ifexp@l@or@a
}%
\def\ekv@ifexp@l@i
##1\ekv@ifexp@none##2%
##3\ekv@ifexp@o
{##2}%
% \end{macrocode}
% easiest route, just \tkn{:}{11}
% \begin{macrocode}
\long\def\ekv@ifexp@l@ii
\ekv@ifexp@l@or@a##1#2##2\ekv@stop
\ekv@ifexp@o\ekv@stop#2\ekv@stop##3%
{\ekv@ifexp@done{##1}\ekv@mark##2}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {
% \ekv@ifexp@l@or@o,
% \ekv@ifexp@l@not@o,\ekv@ifexp@l@not@o@,
% \ekv@ifexp@o@not@l
% }
% slightly harder, \tkn{:}{11} or \tkn{:}{12}, re-split at \tkn{:}{11}
% \begin{macrocode}
\long\def\ekv@ifexp@l@or@o
\ekv@ifexp@o\ekv@ifexp@l@or@a
##1\ekv@stop
{%
\ekv@ifexp@split@l
##1\ekv@nil\ekv@stop\ekv@ifexp@l@not@o
#2\ekv@stop\ekv@ifexp@o@not@l
}%
% \end{macrocode}
% \tkn{:}{11} came earlier than \tkn{:}{12}
% \begin{macrocode}
\long\def\ekv@ifexp@l@not@o##1\ekv@stop
{\ekv@ifexp@l@not@o@{##1}\ekv@mark}
\long\def\ekv@ifexp@l@not@o@
##1##2\ekv@nil#2\ekv@stop\ekv@ifexp@o@not@l
##3#2\ekv@stop##4%
{\ekv@ifexp@done{##1}##2: ##3}%
% \end{macrocode}
% \tkn{:}{12} came earlier than \tkn{:}{11}
% \begin{macrocode}
\long\def\ekv@ifexp@o@not@l
##1\ekv@nil\ekv@stop\ekv@ifexp@l@not@o\ekv@stop
##2#2\ekv@stop##3%
{\ekv@ifexp@done{##1}\ekv@mark##2}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {
% \ekv@ifexp@l@or@a,
% \ekv@ifexp@l@or@a@not@o,
% \ekv@ifexp@l@not@a,\ekv@ifexp@l@not@a@,
% \ekv@ifexp@a@not@l
% }
% \tkn{:}{13} was in the mix with \tkn{:}{11}, we need to see whether there
% was a \tkn{:}{12} as well
% \begin{macrocode}
\def\ekv@ifexp@l@or@a##1%
{%
% \end{macrocode}
% don't get confused by the name, this gobbles until |@none|
% \begin{macrocode}
\ekv@ifexp@a@i
##1\ekv@ifexp@l@or@a@not@o
\ekv@ifexp@none
\ekv@ifexp@l@or@a@or@o
}%
% \end{macrocode}
% phew, no \tkn{:}{12} in the mix, we split at \tkn{:}{13} and see whether an
% earlier \tkn{:}{11} is found
% \begin{macrocode}
\long\def\ekv@ifexp@l@or@a@not@o
\ekv@ifexp@none\ekv@ifexp@l@or@a@or@o
##1#1%
{%
\ekv@ifexp@split@l
##1\ekv@nil\ekv@stop\ekv@ifexp@l@not@a
#2\ekv@stop\ekv@ifexp@a@not@l
}%
\long\def\ekv@ifexp@l@not@a##1\ekv@stop
{\ekv@ifexp@l@not@a@{##1}\ekv@mark}%
\long\def\ekv@ifexp@l@not@a@
##1##2\ekv@nil#2\ekv@stop\ekv@ifexp@a@not@l
##3\ekv@stop\ekv@ifexp@o\ekv@stop#2\ekv@stop##4%
{\ekv@ifexp@done{##1}##2#1##3}%
\long\def\ekv@ifexp@a@not@l
##1\ekv@nil\ekv@stop\ekv@ifexp@l@not@a\ekv@stop
##2\ekv@stop\ekv@ifexp@o\ekv@stop#2\ekv@stop##3%
{\ekv@ifexp@done{##1}\ekv@mark##2}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {
% \ekv@ifexp@l@or@a@or@o,\ekv@ifexp@l@or@a@or@o@i,\ekv@ifexp@l@or@a@or@o@ii,
% \ekv@ifexp@l@or@a@or@o@iii,\ekv@ifexp@l@or@a@or@o@iv,
% \ekv@ifexp@o@not@l@or@a,
% \ekv@ifexp@a@not@l@or@o,\ekv@ifexp@a@not@l@or@o@
% }
% ooh no, the ugliest path, we got ourself a \tkn{:}{11}, a \tkn{:}{12}, and a
% \tkn{:}{13}, first grab everything left after splitting the first
% \tkn{:}{12} and try a \tkn{:}{13} split
% \begin{macrocode}
\long\def\ekv@ifexp@l@or@a@or@o##1\ekv@stop
{%
\ekv@ifexp@split@a@or@l
##1\ekv@nil\ekv@stop\ekv@ifexp@a@not@l@or@o
#1\ekv@stop\ekv@ifexp@o@not@l@or@a
##1\ekv@stop\ekv@ifexp@l@or@a@or@o@i#2\ekv@stop{}%
}%
% \end{macrocode}
% \tkn{:}{12} splitting was correct
% \begin{macrocode}
\long\def\ekv@ifexp@o@not@l@or@a
##1\ekv@nil\ekv@stop\ekv@ifexp@a@not@l@or@o\ekv@stop
##2#2\ekv@stop##3%
{\ekv@ifexp@done{##1}\ekv@mark##2}%
% \end{macrocode}
% \tkn{:}{13} split is correct, \tkn{:}{12} has to be reverted
% \begin{macrocode}
\long\def\ekv@ifexp@a@not@l@or@o##1\ekv@stop
{\ekv@ifexp@a@not@l@or@o@{##1}\ekv@mark}
\long\def\ekv@ifexp@a@not@l@or@o@
##1##2\ekv@nil##3#2\ekv@stop##4%
{\ekv@ifexp@done{##1}##2: ##3}%
% \end{macrocode}
% there is still a \tkn{:}{11} left, we need to take care of \tkn{:}{13} as
% well, but \tkn{:}{12} was wrong
% \begin{macrocode}
\def\ekv@ifexp@l@or@a@or@o@i##1%
{%
\ekv@ifexp@l@or@a@or@o@ii
##1\ekv@ifexp@l@or@a@or@o@iii
\ekv@ifexp@o@not@l@or@a
\ekv@ifexp@why
}%
\def\ekv@ifexp@l@or@a@or@o@ii
##1\ekv@ifexp@o@not@l@or@a
{}%
% \end{macrocode}
% at least it's not absolutely the worst, \tkn{:}{11} is correct, revert the
% \tkn{:}{12} split
% \begin{macrocode}
\long\def\ekv@ifexp@l@or@a@or@o@iii
\ekv@ifexp@o@not@l@or@a\ekv@ifexp@why
##1#2%
{\ekv@ifexp@l@or@a@or@o@iv{##1}\ekv@mark}%
\long\def\ekv@ifexp@l@or@a@or@o@iv
##1##2\ekv@nil\ekv@stop\ekv@ifexp@a@not@l@or@o\ekv@stop
#2\ekv@stop##3##4#2\ekv@stop##5%
{\ekv@ifexp@done{##1}##2: ##4}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {
% \ekv@ifexp@why,
% \ekv@ifexp@why@l,\ekv@ifexp@why@l@i,\ekv@ifexp@why@l@ii,
% \ekv@ifexp@why@a
% }
% why have you forsaken me? We know \tkn{:}{12} was wrong, but now we have
% something that might be correctly split at \tkn{:}{13}, but might as well be
% not
% \begin{macrocode}
\long\def\ekv@ifexp@why##1\ekv@stop
{%
\ekv@ifexp@split@l
##1\ekv@nil\ekv@stop\ekv@ifexp@why@l
#2\ekv@stop\ekv@ifexp@why@a
}%
% \end{macrocode}
% \tkn{:}{11} is correct, rebuild stuff undoing the wrong \tkn{:}{13} split
% \begin{macrocode}
\long\def\ekv@ifexp@why@l##1\ekv@stop
{\ekv@ifexp@why@l@i{##1}\ekv@mark}
\long\def\ekv@ifexp@why@l@i
##1##2\ekv@nil#2\ekv@stop\ekv@ifexp@why@a
{\ekv@ifexp@why@l@ii{##1}##2#1}
% \end{macrocode}
% and undoing the wrong \tkn{:}{12} split
% \begin{macrocode}
\long\def\ekv@ifexp@why@l@ii
##1##2\ekv@nil#2\ekv@stop##3##4#2\ekv@stop##5%
{\ekv@ifexp@done{##1}##2: ##4}%
% \end{macrocode}
% \tkn{:}{13} is correct, we know there is a \tkn{:}{11} hiding somewhere, so
% we don't need to protect against brace strip using a two-step grab here,
% just undoing the wrong \tkn{:}{12} split is enough
% \begin{macrocode}
\long\def\ekv@ifexp@why@a
##1\ekv@nil\ekv@stop\ekv@ifexp@why@l\ekv@stop
##2\ekv@nil#2\ekv@stop##3##4#2\ekv@stop##5%
{\ekv@ifexp@done{##1}\ekv@mark##2: ##4}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {
% \ekv@ifexp@done,\ekv@ifexp@done@,
% \ekv@ifexp@done@test,
% \ekv@ifexp@panic
% }
% once the colon split is done we need to check that there are no spaces in
% the now split of part, if there are \emph{panic} (we did all of this for
% nothing), else we're finally completely done with the splitting business.
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@ifexp@done##1##2\ekv@nil}%
{%
\@firstofone
{\ekv@ifexp@done@test##1\ekv@nil\ekv@ifexp@panic} \ekv@nil{}%
##2\ekv@stop\ekv@ifexp@done@{##1}{##2}\ekv@stop\@secondoftwo
}
\long\def\ekv@ifexp@done@test##1 ##2\ekv@nil##3##4##5##6\ekv@stop{##3}
\ekv@exparg{\long\def\ekv@ifexp@done@##1##2\ekv@stop\@secondoftwo##3}%
{\ekv@strip{##2}{##3{##1}}}%
% \end{macrocode}
% Panic in this case means give up on expansion parsing, instead the normal
% action that would've been done if the expansion mark isn't found is
% executed.
% \begin{macrocode}
\long\def\ekv@ifexp@panic##1\@secondoftwo##2##3{##3}
}
% \end{macrocode}
% \end{macro}
% We set up the strange category codes for colons and do the real definition
% after the temporary one.
% \begin{macrocode}
\begingroup
\catcode`\~=13
\lccode`\~=`\:
\catcode`\z=11
\lccode`\z=`\:
\lowercase{\endgroup
\ekv@ifexp{~ }{z }}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvset}
% Set up |\ekvset|, which should not be affected by active commas and equal
% signs. The equal signs are a bit harder to cope with and we'll do that later,
% but the active commas can be handled by just doing two comma-splitting loops
% one at actives one at others. That's why we define |\ekvset| here with a
% temporary meaning just to set up the things with two different category codes.
% |#1| will be a \texttt{,\textsubscript{13}} and |#2| will be a
% \texttt{=\textsubscript{13}}.
% \begin{macrocode}
\begingroup
\def\ekvset#1#2{%
\endgroup
\ekv@exparg{\long\def\ekvset##1##2}%
{%
\expandafter\expandafter\expandafter
\ekv@set\expandafter\csname\ekv@undefined@set{##1}\endcsname
\ekv@mark##2#1\ekv@stop#1{}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@set}
% |\ekv@set| will split the \kv\ list at active commas. Then it has to check
% whether there were unprotected other commas and resplit there.
% \begin{macrocode}
\long\def\ekv@set##1##2#1%
{%
% \end{macrocode}
% Test whether we're at the end, if so invoke |\ekv@endset|,
% \begin{macrocode}
\ekv@gobble@from@mark@to@stop##2\ekv@endset\ekv@stop
% \end{macrocode}
% else go on with other commas.
% \begin{macrocode}
\ekv@set@other##1##2,\ekv@stop,%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@endset}
% |\ekv@endset| is a hungry little macro. It will eat everything that remains
% of |\ekv@set| and unbrace the sneaked stuff.
% \begin{macrocode}
\long\def\ekv@endset\ekv@stop\ekv@set@other##1\ekv@mark\ekv@stop,\ekv@stop,##2%
{##2}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@eq@other@or@active,\ekv@eq@active}
% Splitting at equal signs will be done in a way that checks whether there is
% an equal sign and splits at the same time. This gets quite messy and the
% code might look complicated, but this is pretty fast (faster than first
% checking for an equal sign and splitting if one is found). The splitting
% code will be adapted for |\ekvset| and |\ekvparse| to get the most speed,
% but some of these macros don't require such adaptions.
% |\ekv@eq@other@or@active| and |\ekv@eq@active| will split the argument at
% the first equal sign. |\ekv@eq@active| will insert the macro which comes
% after the first following |\ekv@mark|, while |\ekv@eq@other@or@active| will
% also check for an active equals sign or none.
% Usage should look like this:
% \begin{syntaxexample*}
% |\ekv@eq@other@or@active|
% \indent|#1\ekv@nil\ekv@mark|\meta{code for \tkn{=}{12}}
% \indent\tkn{=}{12}|\ekv@mark|\meta{code for no equals sign}
% \indent|#1\ekv@mark|\meta{code for \tkn{=}{13} or mixed}
% \indent\tkn{=}{13}|\ekv@mark{}|
% |\ekv@eq@active|
% \indent|#1\ekv@nil\ekv@mark|\meta{code for \tkn{=}{13}}
% \indent\tkn{=}{13}|\ekv@mark|\meta{code for no \tkn{=}{13}}
% \end{syntaxexample*}
% To prevent accidental brace stripping |#1| should be handed in with a
% leading |\ekv@mark|, also that's what the |\ekv@nil| after the first |#1| is
% used for. In |\ekv@eq@other@or@active| four cases are distinguished:
% \begin{enumerate}
% \item
% Only equals signs of category 12 are found, then \meta{code for
% \tkn{=}{12}} will be inserted.
% \item
% No equals sign is found, then \meta{code for no equals sign} will be
% inserted.
% \item
% Only equals signs of category 13 are found, then \meta{code for
% \tkn{=}{13} or mixed} will be inserted, directly followed by
% \meta{code for no equals sign}.
% \item
% Equals signs of categories 12 and 13 are found, then \meta{code for
% \tkn{=}{13} or mixed} directly followed by \meta{code for \tkn{=}{12}}
% will be inserted.
% \end{enumerate}
% This allows for fast branching based on \TeX's argument grabbing rules and
% we don't have to split after the branching if the equal sign was there.
% \begin{macrocode}
\long\def\ekv@eq@other@or@active
##1=##2\ekv@mark##3%
##4#2##5\ekv@mark##6%
{##6##3##1\ekv@stop\ekv@mark##2}
\long\def\ekv@eq@other##1=##2\ekv@mark##3{##3##1\ekv@stop\ekv@mark##2}
\long\def\ekv@eq@active##1#2##2\ekv@mark##3{##3##1\ekv@stop\ekv@mark##2}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@set@other,\ekv@set@next@other}
% The macro |\ekv@set@other| is guaranteed to get only single \kv\ pairs.
% \begin{macrocode}
\long\def\ekv@set@other##1##2,%
{%
% \end{macrocode}
% First we test whether we're done.
% \begin{macrocode}
\ekv@gobble@from@mark@to@stop##2\ekv@endset@other\ekv@stop
% \end{macrocode}
% If not we split at the equal sign of category other.
% \begin{macrocode}
\ekv@eq@other@or@active
##2\ekv@nil\ekv@mark\ekv@set@eq@other
=\ekv@mark\ekv@set@noeq
##2\ekv@mark\ekv@set@eq@active
#2\ekv@mark{}%
% \end{macrocode}
% And put the set name after the splitting.
% \begin{macrocode}
##1%
\ekv@mark
}
% \end{macrocode}
% The second macro is used as a shortcut to gobble two arguments and do the
% same as a following |\ekv@set@other|.
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@set@next@other##1##2\ekv@set@other##3##4,}%
{\ekv@set@other{##3}{##4},}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@endset@other}
% Breaking the current inner loop for \tkn{,}{12} is done by gobbling all the
% remaining tokens and grabbing the next split at an active comma
% (incorporating the next |\ekv@set| call).
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@endset@other
\ekv@stop\ekv@eq@other@or@active
\ekv@mark\ekv@stop\ekv@nil\ekv@mark\ekv@set@eq@other
=\ekv@mark\ekv@set@noeq
\ekv@mark\ekv@stop\ekv@mark\ekv@set@eq@active#2\ekv@mark##1%
##2##3#1}%
{\ekv@set{##2}{##3}#1}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@set@eq@other}
% If this gets called we know that there is no \tkn{=}{13}, hence are done
% with the splitting business. This doesn't even need much clean up, we can
% just strip the \key-name and forward it to |\ekv@set@pair|.
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@set@eq@other##1\ekv@stop}%
{\ekv@strip@key{##1}\ekv@set@pair}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@set@if@noeq}
% In the case that there was at least one \tkn{=}{13} we need a way to know
% whether there also was a \tkn{=}{12}. This here can be used to check this by
% only looking for |\ekv@set@noeq|.
% \begin{macrocode}
\def\ekv@set@if@noeq##1\ekv@set@noeq{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@set@eq@active,\ekv@set@eq@active@}
% The first token after this will either be |\ekv@set@noeq| or
% |\ekv@set@eq@other|. We test this and branch accordingly.
% \begin{macrocode}
\def\ekv@set@eq@active##1%
{\ekv@set@if@noeq##1\ekv@set@eq@active@\ekv@set@noeq\ekv@set@eq@mixed}
% \end{macrocode}
% Since we know that there was no \tkn{=}{12} when the next macro is called we
% can simply do the correct split without any checks and forward to
% |\ekv@set@pair|.
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@set@eq@active@
\ekv@set@noeq\ekv@set@eq@mixed
##1#2##2\ekv@mark
\ekv@set@eq@other\ekv@stop\ekv@mark#2\ekv@mark##3}%
{\ekv@strip@key{##1}\ekv@set@pair\ekv@mark##2}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {\ekv@set@eq@mixed,\ekv@set@eq@mixed@o,\ekv@set@mixed@a}
% In the mixed case we grab until the first split of \tkn{=}{12} already done,
% and resplit at \tkn{=}{13} using the conditonal splitter described earlier.
% \begin{macrocode}
\long\def\ekv@set@eq@mixed##1\ekv@stop
{%
\ekv@eq@active##1\ekv@nil\ekv@mark\ekv@set@eq@mixed@a
#2\ekv@mark\ekv@set@eq@mixed@o
}
% \end{macrocode}
% If there actually was no \tkn{=}{13} before the first \tkn{=}{12} everything
% was fine. We pick up our first split and remove the gibberish left by the
% conditional splitter.
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@set@eq@mixed@o
##1\ekv@nil\ekv@mark\ekv@set@eq@mixed@a\ekv@stop\ekv@mark
##2\ekv@nil#2\ekv@mark##3}%
{\ekv@strip@key{##1}\ekv@set@pair##2\ekv@nil}
% \end{macrocode}
% |\ekv@set@eq@mixed@a| will trigger if before the first \tkn{=}{12} there was
% already a \tkn{=}{13}. So we use the new split and revert the erroneous
% split at \tkn{=}{12}.
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@set@eq@mixed@a
##1\ekv@stop
##2\ekv@nil#2\ekv@mark\ekv@set@eq@mixed@o\ekv@mark
##3#2\ekv@mark##4}%
{\ekv@strip@key{##1}\ekv@set@pair##2=##3}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@set@noeq,\ekv@set@was@blank}
% If there was no equals sign the current element might in fact be blank.
% Blank elements are ignored, hence we need to check for that, else we can
% call |\ekv@set@key|.
% \begin{macrocode}
\ekv@expandedarg
{%
\long\def\ekv@set@noeq
##1\ekv@nil\ekv@mark\ekv@set@eq@other\ekv@stop\ekv@mark
}%
{%
\ekv@unexpanded
{%
\ekv@ifblank@##1\ekv@stop\ekv@ifblank@gobbletrue
\ekv@stop\ekv@set@was@blank
}%
\ekv@unexpanded\expandafter{\ekv@strip@key{##1}\ekv@set@key}%
}
% \end{macrocode}
% If in fact the element was blank we remove the |\ekv@set@key| call and
% instead do the next iteration of |\ekv@set@other|.
% \begin{macrocode}
\ekv@exparg{\long\expandafter\def\expandafter\ekv@set@was@blank
\ekv@strip@key{\ekv@mark##1}\ekv@set@key
##2##3,}%
{\ekv@set@other{##2}{##3},}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvbreak,\ekvbreakPreSneak,\ekvbreakPostSneak}
% Provide macros that can completely stop the parsing of |\ekvset|, who knows
% what it'll be useful for.
% \begin{macrocode}
\long\def\ekvbreak##1##2\ekv@stop#1##3{##1}
\long\def\ekvbreakPreSneak ##1##2\ekv@stop#1##3{##1##3}
\long\def\ekvbreakPostSneak##1##2\ekv@stop#1##3{##3##1}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvsneak,\ekvsneakPre}
% One last thing we want to do for |\ekvset| is to provide macros that just
% smuggle stuff after |\ekvset|'s effects.
% \begin{macrocode}
\long\def\ekvsneak##1##2\ekv@stop#1##3{##2\ekv@stop#1{##3##1}}
\long\def\ekvsneakPre##1##2\ekv@stop#1##3{##2\ekv@stop#1{##1##3}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvparse}
% Additionally to the |\ekvset| macro we also want to provide an |\ekvparse|
% macro, that has the same scope as |\keyval_parse:NNn| from \pkg{expl3}.
% This is pretty analogue to the |\ekvset| implementation, we just put an
% |\unexpanded| here and there instead of other macros to stop the |\expanded|
% on our output. The |\unexpanded\expanded{{...}}| ensures that the material
% is in an alignment safe group at all time, and that it doesn't expand any
% further in an |\edef| or |\expanded| context.
% \begin{macrocode}
\long\def\ekvparse##1##2##3%
{%
\ekv@unexpanded\ekv@expanded
{{\ekv@parse{##1}{##2}\ekv@mark##3#1\ekv@stop#1}}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse}
% \begin{macrocode}
\long\def\ekv@parse##1##2##3#1%
{%
\ekv@gobble@from@mark@to@stop##3\ekv@endparse\ekv@stop
\ekv@parse@other{##1}{##2}##3,\ekv@stop,%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@endparse}
% \begin{macrocode}
\long\def\ekv@endparse\ekv@stop\ekv@parse@other##1\ekv@mark\ekv@stop,\ekv@stop,%
{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse@other}
% \begin{macrocode}
\long\def\ekv@parse@other##1##2##3,%
{%
\ekv@gobble@from@mark@to@stop##3\ekv@endparse@other\ekv@stop
\ekv@eq@other@or@active
##3\ekv@nil\ekv@mark\ekv@parse@eq@other
=\ekv@mark\ekv@parse@noeq
##3\ekv@mark\ekv@parse@eq@active#2\ekv@mark{}%
{##1}{##2}%
\ekv@mark
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@endparse@other}
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@endparse@other
\ekv@stop\ekv@eq@other@or@active
\ekv@mark\ekv@stop\ekv@nil\ekv@mark\ekv@parse@eq@other
=\ekv@mark\ekv@parse@noeq
\ekv@mark\ekv@stop\ekv@mark\ekv@parse@eq@active#2\ekv@mark##1%
##2##3##4#1}%
{\ekv@parse{##2}{##3}{##4}#1}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse@eq@other}
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@parse@eq@other##1\ekv@stop}%
{\ekv@strip{##1}\ekv@parse@pair}%
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse@if@noeq}
% \begin{macrocode}
\def\ekv@parse@if@noeq##1\ekv@parse@noeq{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse@eq@active,\ekv@parse@eq@active@}
% \begin{macrocode}
\def\ekv@parse@eq@active##1%
{%
\ekv@parse@if@noeq##1\ekv@parse@eq@active@\ekv@parse@noeq
\ekv@parse@eq@mixed
}
\ekv@exparg{\long\def\ekv@parse@eq@active@
\ekv@parse@noeq\ekv@parse@eq@mixed
##1#2##2\ekv@mark
\ekv@parse@eq@other\ekv@stop\ekv@mark#2\ekv@mark##3}%
{\ekv@strip{##1}\ekv@parse@pair\ekv@mark##2}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {\ekv@parse@eq@mixed,\ekv@parse@eq@mixed@o,\ekv@parse@eq@mixed@a}
% \begin{macrocode}
\long\def\ekv@parse@eq@mixed##1\ekv@stop
{%
\ekv@eq@active##1\ekv@nil\ekv@mark\ekv@parse@eq@mixed@a
#2\ekv@mark\ekv@parse@eq@mixed@o
}
\ekv@exparg{\long\def\ekv@parse@eq@mixed@a
##1\ekv@stop
##2\ekv@nil#2\ekv@mark\ekv@parse@eq@mixed@o\ekv@mark
##3#2\ekv@mark##4}%
{\ekv@strip{##1}\ekv@parse@pair##2=##3}
\ekv@exparg{\long\def\ekv@parse@eq@mixed@o
##1\ekv@nil\ekv@mark\ekv@parse@eq@mixed@a\ekv@stop\ekv@mark
##2\ekv@nil#2\ekv@mark##3}%
{\ekv@strip{##1}\ekv@parse@pair##2\ekv@nil}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse@noeq,\ekv@parse@was@blank}
% \begin{macrocode}
\ekv@expandedarg
{%
\long\def\ekv@parse@noeq
##1\ekv@nil\ekv@mark\ekv@parse@eq@other\ekv@stop\ekv@mark
}%
{%
\ekv@unexpanded
{%
\ekv@ifblank@##1\ekv@stop\ekv@ifblank@gobbletrue
\ekv@stop\ekv@parse@was@blank
}%
\ekv@unexpanded\expandafter{\ekv@strip{##1}\ekv@parse@key}%
}
\ekv@exparg{\long\expandafter\def\expandafter\ekv@parse@was@blank
\ekv@strip{\ekv@mark##1}\ekv@parse@key
##2##3##4,}%
{\ekv@parse@other{##2}{##3}{##4},}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse@pair,\ekv@parse@pair@}
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@parse@pair##1##2\ekv@nil}%
{\ekv@strip{##2}\ekv@parse@pair@{##1}}
\ekv@exparg{\long\def\ekv@parse@pair@##1##2##3##4}%
{%
\ekv@ifexp{##2}%
{\ekv@expansion@parse@pair{##1}{##4}}%
{\ekv@unexpanded{##4{##2}{##1}}}%
\ekv@parse@other{##3}{##4}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@parse@key}
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@parse@key##1##2}%
{%
\ekv@ifexp{##1}%
{\ekv@expansion@parse@key{##2}}%
{\ekv@unexpanded{##2{##1}}}%
\ekv@parse@other{##2}%
}
% \end{macrocode}
% \end{macro}
%
% Finally really setting things up with |\ekvset|'s temporary meaning:
% \begin{macrocode}
}
\catcode`\,=13
\catcode`\==13
\ekvset,=
% \end{macrocode}
%
% \begin{macro}{\ekvsetSneaked}
% This macro can be defined just by expanding |\ekvsneak| once after expanding
% |\ekvset|. To expand everything as much as possible early on we use a
% temporary definition.
% \begin{macrocode}
\edef\ekvsetSneaked
{%
\ekv@unexpanded{\ekvsneak{#2}}%
\ekv@unexpanded\expandafter{\ekvset{#1}{#3}}%
}
\ekv@expargtwice{\long\def\ekvsetSneaked#1#2#3}{\ekvsetSneaked}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvchangeset}
% Provide a macro that is able to switch out the current \set\ in |\ekvset|.
% This operation allows something similar to \pkg{pgfkeys}'s
% \texttt{\meta{key}/.cd} mechanism. However this operation can be more
% expensive than |/.cd| as we can't just redefine some token to reflect this,
% but have to switch out the set expandably, so this works similar to the
% |\ekvsneak| macros reading and reinserting things, but it only has to read and
% reinsert the remainder of the current key's replacement code.
% \begin{macrocode}
\ekv@exparg{\def\ekvchangeset#1}%
{%
\expandafter\expandafter\expandafter
\ekv@changeset\expandafter\csname\ekv@undefined@set{#1}\endcsname\ekv@empty
}
% \end{macrocode}
% \begin{macro}[internal]{\ekv@changeset}
% This macro does the real change-out of |\ekvchangeset|. |#2| will have a
% leading |\ekv@empty| so that braces aren't stripped accidentally, but that
% will not hurt and just expand to nothing in one step.
% \begin{macrocode}
\long\def\ekv@changeset#1#2\ekv@set@other#3{#2\ekv@set@other#1}
% \end{macrocode}
% \end{macro}
% \end{macro}
%
% \begin{macro}{\ekvmorekv}
% |\ekvmorekv| injects additional keys for consideration without needing a
% nested |\ekvset|. The issue we're facing here is that we can only inject
% after the next |\ekv@set@other| to not destroy the order of things, but in
% theory the argument to |\ekvmorekv| could contain an active comma. Now we
% have two options:
% \begin{enumerate}
% \item reread all keys until the end of the current |\ekv@set@other| loop
% to change the commas there to an active one and insert |\ekv@set|
% instead
% \item loop over the argument of |\ekvmorekv| to remove all top-level
% active commas and replace them with ones of category 12.
% \end{enumerate}
% The following implements the second approach. We use a temporary definition
% of |\ekvmorekv| to get us |#1| for active commas. For the comma replacement
% we set up a small loop. The |\ekv@empty| at the end of |\ekvmorekv|'s
% definition protects against accidental brace loss in user code.
% \begin{macrocode}
\def\ekvmorekv#1%
{%
\long\def\ekvmorekv##1%
{%
\expandafter\ekv@morekv\ekv@expanded
{{\ekv@morekv@loop\ekv@empty##1\ekv@stop\ekv@morekv@done#1}}%
\ekv@empty
}%
% \end{macrocode}
% \begin{macro}[internal]{\ekv@parse@more,\ekv@parse@more@}
% For the expansion control we also need a way to support reinsertion in
% |\ekvparse|. Since there no user code is executed this is an internal macro.
% It works in the same way but the argument order exchange is different. Also,
% since this is only used internally, we know it is safe to omit the trailing
% |\ekv@empty|.
% \begin{macrocode}
\long\def\ekv@parse@more##1\@gobble##2%
{%
\expandafter\ekv@parse@more@\ekv@expanded
{{\ekv@morekv@loop\ekv@empty##1\ekv@stop\ekv@morekv@done#1}}%
}%
\long\def\ekv@parse@more@##1\ekv@parse@other##2##3\ekv@mark
{\ekv@parse@other{##2}{##3}\ekv@mark##1,}%
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]{\ekv@morekv}
% This is just a simple change of argument order, injecting the new comma
% separated list after the current |\ekv@set@other| call.
% \begin{macrocode}
\long\def\ekv@morekv##1##2\ekv@set@other##3\ekv@mark
{##2\ekv@set@other##3\ekv@mark##1,}
% \end{macrocode}
% \end{macro}
% \begin{macro}[internal]
% {\ekv@morekv@loop,\ekv@morekv@done,\ekv@morekv@wrap}
% And here is the heavy lifting of the comma replacement. Each list element
% until the next active comma is read and left as an argument for
% |\ekv@morekv@wrap|, that will remove the leading |\ekv@empty|. The trick for
% a fast end of the loop is that |\ekv@morekv@wrap| will read until the next
% |\ekv@stop|, of which an additional one is put before |\ekv@morekv@done| so
% that |wrap| will wrap the real end of the list and then |done| removes the
% excess code.
% \begin{macrocode}
\long\def\ekv@morekv@loop##1#1%
{\ekv@morekv@wrap##1\ekv@stop,\ekv@morekv@loop\ekv@empty}%
\long\def\ekv@morekv@wrap##1\ekv@stop{\ekv@unexpanded\expandafter{##1}}%
\def\ekv@morekv@done\ekv@stop,\ekv@morekv@loop\ekv@empty{}%
}
\begingroup\catcode`\,=13 \@firstofone{\endgroup\ekvmorekv,}
% \end{macrocode}
% \end{macro}
% \end{macro}
%
%
% \begin{macro}[internal]
% {
% \ekv@def@expansion@rule,\ekv@def@expansion@rule@ea,
% \ekv@expansion@rule@,\ekv@expansion@csname
% }
% All expansion rules share the same basic structure, they do their expansion
% step and then call |\ekv@expansion@rule@| (this could be done faster by
% letting each rule build the macro for the next rule in |\csname|, but that
% would require a more complex argument grabbing structure of the rules, and
% we'd need to use |\expanded{\unexpanded{\csname ...\endcsname}\expandafter}|
% or similar to not do the expansion steps of the \val\ inside of |\csname|).
% As a result of this the \val\ needs to be grabbed twice per expansion step.
% \begin{macrocode}
\protected\def\ekv@def@expansion@rule#1#2#3#4%
{%
\long\expandafter\def\csname ekv@expansion@rule@#1\endcsname##1#2%
{#3\ekv@expansion@rule@#4}%
}
\protected\def\ekv@def@expansion@rule@ea#1#2%
{\ekv@def@expansion@rule{#1}{#2}\expandafter}
% \end{macrocode}
% Rules follow this naming scheme. Note that for an undefined rule an error is
% thrown and the result of the |\csname| is |\ekv@expansion@rule@|.
% \begin{macrocode}
\long\def\ekv@expansion@csname#1\ekv@stop
{%
ekv@expansion@rule@%
\ifcsname ekv@expansion@rule@#1\endcsname
#1%
\else
\ekv@err@undefined@expansion{#1}%
\fi
}
% \end{macrocode}
% This auxiliary macro simply builds the next rule, it is used to start an
% expansion chain, as well as for each defined or undefined rule.
% \begin{macrocode}
\long\def\ekv@expansion@rule@#1#2%
{\csname\expandafter\ekv@expansion@csname\string#2\ekv@stop\endcsname{#1}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@expansion@rule@\ekv@mark}
% The expansion chain is ended by an internal rule that behaves very different
% from the others. It'll test whether the |r|-rule was used (in which case the
% third argument will not be empty, and also execute that reinsertion) or grab
% the code for the next step after the expansion.
% \begin{macrocode}
\ekv@exparg
{%
\long\expandafter
\def\csname ekv@expansion@rule@\string\ekv@mark\endcsname
#1\ekv@stop#2#3#4#5%
}%
{%
\romannumeral\ekv@exparg{\expandafter\ekv@zero\ekv@ifempty{#3}{#5{#2}{#1}}}%
{\ekv@ifempty{#2}{#4{#1}}{\ekv@err@val@no@reinsert{#2}}}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \ekv@expansion@rule@o,\ekv@expansion@rule@e,\ekv@expansion@rule@c,
% \ekv@expansion@rule@f,\ekv@expansion@rule@V,\ekv@expansion@rule@v,
% \ekv@expansion@rule@s,\ekv@expansion@rule@b,\ekv@expansion@rule@\r,
% \ekv@expansion@rule@g,\ekv@expansion@rule@p,\ekv@expansion@rule@P,
% \ekv@expansion@rule@r,\ekv@expansion@rule@R
% }
% All the expansion rules are executed inside a |\csname| construct, so they
% have to issue an |\endcsname| after the intended expansion took place. I
% guess the code is pretty straight forward here.
% \begin{macrocode}
\ekv@def@expansion@rule@ea{o}{}{\expandafter{#1}}
\ekv@def@expansion@rule@ea{e}{}{\ekv@expanded{{#1}}}
\ekv@def@expansion@rule@ea{c}{}{\csname#1\endcsname}
\ekv@def@expansion@rule@ea{f}{}{\expandafter{\romannumeral`\^^@#1}}
\ekv@exparg{\ekv@def@expansion@rule{s}{}}{\ekv@strip{\ekv@mark#1}}{}
\ekv@def@expansion@rule{b}{}{}{{{#1}}}
\ekv@def@expansion@rule{\string\r}{#2\ekv@stop#3#4}{}{{#1}#2\ekv@stop{#3}{#4r}}
\ekv@def@expansion@rule@ea{g}{}{\expandafter{\@gobble#1}}
\ekv@def@expansion@rule{p}{#2}{}{{#2#1}}
\ekv@def@expansion@rule{P}{#2}{}{{#1#2}}
% \end{macrocode}
% The |V| and |v| rules are a bit more complicated. They use some auxiliaries
% but otherwise should be more or less obvious as well. The |v| one uses some
% expansion to get a more meaningful error message in case the resulting
% control sequence would be undefined (without actually using |\csname|, to
% not accidentally define anything as |\relax|).
% \begin{macrocode}
\long\def\ekv@expansion@rule@V#1%
{%
\ifx\relax#1\ekv@err@erroneous@variable{#1}\ekv@expansion@@clean@V\fi
\ekv@expansion@@V{#1}%
}
\ekv@expandedarg{\long\def\ekv@expansion@rule@v#1}%
{%
\ekv@unexpanded{\ekv@ifdefined{#1}%
{\expandafter\ekv@expansion@@V\csname#1\endcsname}}%
{%
\ekv@unexpanded{\expandafter\ekv@err@erroneous@variable\ekv@expanded}%
{{\expandafter\@gobble\string\\#1}}%
\ekv@unexpanded{\ekv@expansion@rule@}{}%
}%
}
\ekv@exparg{\long\def\ekv@expansion@rule@r#1#2\ekv@stop#3#4}%
{\ekv@expansion@rule@v{#1}#2\ekv@stop{#3}{#4r}}
\ekv@exparg{\long\def\ekv@expansion@rule@R#1#2\ekv@stop#3#4}%
{\ekv@expansion@rule@V{#1}#2\ekv@stop{#3}{#4r}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@expansion@@V,\ekv@expansion@@clean@V}
% The actual |V| evaluation is pretty much the same as in \pkg{expl3}, but we
% need to put braces around the expansion result, hence branch slightly
% differently. In general, a macro will temporarily have the meaning of
% |\relax| if hit by |\noexpand| and hence the \cs[no-index]{ifx} test will
% result in false (as the meaning isn't the same now), so we can tell
% whether it would expand directly. Else we assume this is a register type and
% use |\the|.
% \begin{macrocode}
\long\def\ekv@expansion@@V#1%
{%
\expandafter\ifx\noexpand#1#1%
\ekv@fi@firstoftwo
\fi
\@secondoftwo
{\expandafter\ekv@expansion@rule@\expandafter{\the#1}}%
{\expandafter\ekv@expansion@rule@\expandafter{#1}}%
}
\long\def\ekv@expansion@@clean@V\fi\ekv@expansion@@V#1%
{\fi\ekv@expansion@rule@{}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {\ekv@expansion@rule@\key,\ekv@expansion@rule@\ekv@key@after}
% The |\key|-rule works by calling a nested expansion chain with swapped \key\
% and \val. Instead of |\ekv@mark| marking the end of the expansion chain
% we use a different final step called |\ekv@key@after|, that simply checks
% whether an |r|-rule was executed (\emph{error}) and ends the current
% expansion step in the outer chain.
% \begin{macrocode}
\ekv@def@expansion@rule{\string\key}{#2#3\ekv@stop#4}%
{}{{#4}#2\ekv@key@after\ekv@stop{#1}{}{#3}}
\ekv@exparg{\ekv@def@expansion@rule{\string\ekv@key@after}{\ekv@stop#2#3#4}}%
{\ekv@ifempty{#3}{}\ekv@err@key@no@reinsert}
{{#2}#4\ekv@stop{#1}}
% \end{macrocode}
% \end{macro}
%
%
% \begin{macro}[internal]
% {
% \ekv@set@pair,\ekv@set@pair@,
% \ekv@set@pair@relax,\ekv@set@pair@undefined,
% \ekv@set@pair@u,\ekv@set@pair@u@relax,\ekv@set@pair@no@u
% }
% |\ekv@set@pair| gets invoked with the space and brace stripped key-name as
% its first, the value as the second (delimited by |\ekv@nil|), and the set
% name as the third argument. It provides tests for the key-macros and
% everything to be able to throw meaningful error messages if it isn't
% defined. We have two routes here, one if |\lastnamedcs| is defined and one
% if it isn't. The big difference is that if it is we can omit a |\csname| and
% instead just expand |\lastnamedcs| once to get the control sequence.
% If the macro is defined the value will be space and brace stripped and the
% key-macro called. Else branch into the error handling provided by
% |\ekv@set@pair@undefined|.
% \begin{macrocode}
\ekv@if@lastnamedcs
{%
\long\def\ekv@set@pair#1\ekv@mark#2#3\ekv@nil#4%
{%
\ifcsname#4{#1}\endcsname\expandafter\ekv@set@pair@\lastnamedcs\fi
\ekv@set@pair@undefined{#3}{#1}{#2}%
\ekv@set@other#4%
}
\ekv@exparg{\long\def\ekv@set@pair@undefined#1#2#3\ekv@set@other#4}%
{%
\romannumeral
\ekv@exparg
{\expandafter\ekv@zero\ekv@ifexp{#3}}%
{\ekv@strip{#1}\ekv@expansion@set@pair}%
{%
\ifcsname#4{}u\endcsname\expandafter\ekv@set@pair@u\lastnamedcs\fi
\ekv@set@pair@no@u{#1}{#2}{#3}%
}%
\ekv@set@other#4%
}
}
{%
\long\def\ekv@set@pair#1\ekv@mark#2#3\ekv@nil#4%
{%
\ifcsname#4{#1}\endcsname
\expandafter\ekv@set@pair@\csname#4{#1}\endcsname
\fi
\ekv@set@pair@undefined{#3}{#1}{#2}%
\ekv@set@other#4%
}
\ekv@exparg{\long\def\ekv@set@pair@undefined#1#2#3\ekv@set@other#4}%
{%
\romannumeral
\ekv@exparg
{\expandafter\ekv@zero\ekv@ifexp{#3}}%
{\ekv@strip{#1}\ekv@expansion@set@pair}%
{%
\ifcsname#4{}u\endcsname
\expandafter\ekv@set@pair@u\csname#4{}u\endcsname
\fi
\ekv@set@pair@no@u{#1}{#2}{#3}%
}%
\ekv@set@other#4%
}
}
\ekv@expandedarg{\long\def\ekv@set@pair@#1\fi\ekv@set@pair@undefined#2}%
{%
\ekv@unexpanded{\fi\ifx#1\relax\ekv@set@pair@relax\fi}%
\ekv@unexpanded\expandafter{\ekv@strip{#2}#1\ekv@set@next@other}%
}
\ekv@expandafter{\long\def\ekv@set@pair@relax\fi}%
\ekv@strip{#1}#2\ekv@set@next@other
{\fi\ekv@set@pair@undefined{#1}}
\ekv@expandedarg{\long\def\ekv@set@pair@u#1\fi\ekv@set@pair@no@u#2}%
{%
\ekv@unexpanded
{%
\fi
\ifx\relax#1%
\ekv@set@pair@u@relax
\fi
}%
\ekv@unexpanded\expandafter{\ekv@strip{#2}#1}%
}
\ekv@expandafter{\long\def\ekv@set@pair@u@relax\fi}\ekv@strip{\ekv@mark#1}#2%
{\fi\ekv@set@pair@no@u.}
\long\def\ekv@set@pair@no@u#1#2#3\ekv@set@other#4%
{%
\ekv@ifdefined{#4{#2}N}%
\ekv@err@noarg
\ekv@err@unknown
#4{#2}{#3}%
\ekv@set@other#4%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \ekv@set@key,\ekv@set@key@,
% \ekv@set@key@relax,\ekv@set@key@undefined,
% \ekv@set@key@u,\ekv@set@key@u@relax,\ekv@set@key@no@u
% }
% Analogous to |\ekv@set@pair|, |\ekv@set@key| builds the \Nkey-macro and
% provides an error-branch. It'll test whether the key-macro is defined and if
% so call it, else there might be some \expnotation, or errors are thrown.
% \begin{macrocode}
\ekv@if@lastnamedcs
{%
\long\def\ekv@set@key#1\ekv@mark#2#3%
{%
\ifcsname#3{#1}N\endcsname\expandafter\ekv@set@key@\lastnamedcs\fi
\ekv@set@key@undefined{#1}{#2}%
\ekv@set@other#3%
}
\ekv@exparg{\long\def\ekv@set@key@undefined#1#2\ekv@set@other#3}%
{%
\ekv@ifexp{#2}%
\ekv@expansion@set@key
{%
\ifcsname#3{}uN\endcsname\expandafter\ekv@set@key@u\lastnamedcs\fi
\ekv@set@key@no@u{#1}{#2}%
}%
\ekv@set@other#3%
}
}
{%
\long\def\ekv@set@key#1\ekv@mark#2#3%
{%
\ifcsname#3{#1}N\endcsname
\expandafter\ekv@set@key@\csname#3{#1}N\endcsname
\fi
\ekv@set@key@undefined{#1}{#2}%
\ekv@set@other#3%
}
\ekv@exparg{\long\def\ekv@set@key@undefined#1#2\ekv@set@other#3}%
{%
\ekv@ifexp{#2}%
\ekv@expansion@set@key
{%
\ifcsname#3{}uN\endcsname
\expandafter\ekv@set@key@u\csname#3{}uN\endcsname
\fi
\ekv@set@key@no@u{#1}{#2}%
}%
\ekv@set@other#3%
}
}
\long\def\ekv@set@key@#1\fi\ekv@set@key@undefined
{\fi\ifx#1\relax\ekv@set@key@relax\fi#1\ekv@set@next@other}
\long\def\ekv@set@key@relax\fi#1\ekv@set@next@other{\fi\ekv@set@key@undefined}
\long\def\ekv@set@key@u#1\fi\ekv@set@key@no@u
{\fi\ifx\relax#1\ekv@set@key@u@relax\fi#1}
\def\ekv@set@key@u@relax\fi#1{\fi\ekv@set@key@no@u}
\long\def\ekv@set@key@no@u#1#2\ekv@set@other#3%
{%
\ekv@ifdefined{#3{#1}}%
\ekv@err@reqval
\ekv@err@unknown
#3{#1}{#2}%
\ekv@set@other#3%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \ekv@expansion@set@key,\ekv@expansion@set@key@,
% \ekv@expansion@set@pair,\ekv@expansion@set@pair@
% }
% These macros just pick up the pieces of the \expansion\ prefix as separate
% arguments. The \val\ for the \expansion-rules is left empty. Once expansion
% is done we loop back to |\ekv@set@key|, that'll pick up the processed \key\
% and set it if it's now defined. The same trick is used for a \kv\ pair.
% \begin{macrocode}
\long\def\ekv@expansion@set@key#1#2#3%
{%
\ekv@expansion@rule@{#2}#1\ekv@mark\ekv@stop{}{}\ekvmorekv
\ekv@expansion@set@key@
}
\long\def\ekv@expansion@set@key@#1#2\ekv@set@other#3%
{\expandafter\ekv@set@key\detokenize{#2}\ekv@mark{#2}#3}
\long\def\ekv@expansion@set@pair#1#2#3#4%
{%
\ekv@expansion@rule@{#1}#2\ekv@mark\ekv@stop{#3}{}\ekvmorekv
\ekv@expansion@set@pair@
}
\long\def\ekv@expansion@set@pair@#1#2\ekv@set@other#3%
{\expandafter\ekv@set@pair\detokenize{#1}\ekv@mark{#1}\ekv@mark{#2}\ekv@nil#3}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \ekv@expansion@parse@key,\ekv@expansion@parse@key@,
% \ekv@expansion@parse@pair,\ekv@expansion@parse@pair@
% }
% In |\ekvparse| we don't need to resort to looping back into |\ekv@parse@key|
% or the like, we can simply leave the result via |\ekv@unexpanded|.
% \begin{macrocode}
\long\def\ekv@expansion@parse@key#1#2#3#4%
{%
\ekv@expansion@rule@{#3}#2\ekv@mark\ekv@stop{}{}\ekv@parse@more
\ekv@expansion@parse@key@\@gobble{#1}%
}
\long\def\ekv@expansion@parse@key@#1#2\@gobble#3{\ekv@unexpanded{#3{#2}}}
\long\def\ekv@expansion@parse@pair#1#2#3#4#5%
{%
\ekv@expansion@rule@{#1}#3\ekv@mark\ekv@stop{#4}{}\ekv@parse@more
\ekv@expansion@parse@pair@\@gobble{#2}%
}
\long\def\ekv@expansion@parse@pair@#1#2\@gobble#3{\ekv@unexpanded{#3{#1}{#2}}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvsetdef}
% Provide a macro to define a shorthand to use |\ekvset| on a specified \set.
% To gain the maximum speed |\ekvset| is expanded twice by
% |\ekv@exparg| so that during runtime the macro storing the set name
% is already built and one |\expandafter| doesn't have to be used.
% \begin{macrocode}
\ekv@exparg{\protected\def\ekvsetdef#1#2}%
{%
\romannumeral
\ekv@exparg{\expandafter\ekv@zero\ekv@exparg{\def#1##1}}%
{\ekvset{#2}{##1}}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvsetSneakeddef,\ekvsetdefSneaked}
% And do the same for |\ekvsetSneaked| in the two possible ways, with a fixed
% sneaked argument and with a flexible one.
% \begin{macrocode}
\ekv@exparg{\protected\def\ekvsetSneakeddef#1#2}%
{%
\romannumeral
\ekv@exparg{\expandafter\ekv@zero\ekv@exparg{\def#1##1##2}}%
{\ekvsetSneaked{#2}{##1}{##2}}%
}
\ekv@exparg{\protected\long\def\ekvsetdefSneaked#1#2#3}%
{%
\romannumeral
\ekv@exparg{\expandafter\ekv@zero\ekv@exparg{\def#1##1}}%
{\ekvsetSneaked{#2}{#3}{##1}}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@alignsafe,\ekv@endalignsafe}
% These macros protect the usage of ampersands inside of alignment contexts.
% \begin{macrocode}
\begingroup
\catcode`\^^@=2
\@firstofone{\endgroup
\def\ekv@alignsafe{\romannumeral\iffalse{\fi`^^@ }
}
\begingroup
\catcode`\^^@=1
\@firstofone{\endgroup
\edef\ekv@endalignsafe{\ekv@unexpanded{\romannumeral`^^@\iffalse}\fi} }
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvoptarg,\ekvoptargTF}
% Provide macros to expandably collect an optional argument in brackets. The
% macros here are pretty simple in nature compared to \pkg{xparse}'s
% possibilities (they don't care for nested bracket levels).
%
% We start with a temporary definition to pre-expand |\ekv@alignsafe| (will be
% |#1|) and |\ekv@endalignsafe| (will be |#2|). As |\ekv@alignsafe| starts with
% a |\romannumeral| we use that to also control the number of steps needed
% instead of adding another |\romannumeral|. For this we have to remove the
% space token from the end of |\ekv@alignsafe|'s definition.
% \begin{macrocode}
\begingroup
\def\ekvoptarg#1#2{%
\endgroup
% \end{macrocode}
% The real definition starts an expansion context and afterwards grabs the
% arguments. |#1| will be the next step, |#2| the default value, and |#3| might
% be an opening bracket, or the mandatory argument. We check for the opening
% bracket, if it is found grab the optional argument, else leave |#1{#2}| in the
% input stream after ending the expansion context.
% \begin{macrocode}
\def\ekvoptarg{#1\ekv@optarg@a}
\long\def\ekv@optarg@a##1##2##3%
{%
\ekv@optarg@if\ekv@mark##3\ekv@mark\ekv@optarg@b\ekv@mark[\ekv@mark
#2%
\@firstofone{ ##1}{##2}{##3}%
}%
% \end{macrocode}
% The other variant of this will do roughly the same. Here, |#1| will be the
% next step if an optional argument is found, |#2| the next step else, and |#3|
% might be the opening bracket or mandatory argument.
% \begin{macrocode}
\def\ekvoptargTF{#1\ekv@optargTF@a}
\long\def\ekv@optargTF@a##1##2##3%
{%
\ekv@optarg@if\ekv@mark##3\ekv@mark\ekv@optargTF@b{##1}\ekv@mark[\ekv@mark
#2%
\@firstofone{ ##2}{##3}%
}
% \end{macrocode}
% The two macros to grab the optional argument have to remove the remainder of
% the test and the wrong next step as well as grabbing the argument.
% \begin{macrocode}
\@firstofone{\long\def\ekv@optarg@b
\ekv@mark[\ekv@mark\romannumeral`##1\fi} \@firstofone##2##3##4##5]%
{#2##2{##5}}
\@firstofone{\long\def\ekv@optargTF@b
##1\ekv@mark[\ekv@mark\romannumeral`##2\fi} \@firstofone##3##4##5]%
{#2 ##1{##5}}
}
% \end{macrocode}
% Do the definitions and add the test macro. We use |\ekv@strip| to remove the
% trailing space from the definition of |\ekv@alignsafe|.
% \begin{macrocode}
\ekv@exparg
{\ekv@exparg\ekv@strip{\expandafter\ekv@mark\ekv@alignsafe}\ekvoptarg}%
\ekv@endalignsafe
\long\def\ekv@optarg@if#1\ekv@mark[\ekv@mark{}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@ifstar}
% Internal helper to get an expandable |ifstar| implementation. This is pretty
% straight forward.
% \begin{macrocode}
\long\def\ekv@ifstar#1#2#3%
{%
\ekv@ifatmostone{#3}%
{\if*\string#3\ekv@fi@firstoftwo\fi}%
{}%
\@secondoftwo
{#1}%
{#2{#3}}%
}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}{\ekvcompile}
% The idea of key-compilation is to preparse some list into a form that sets
% that list very fast (but is frozen), in our case this means we do everything
% except expanding the key's code. There are two levels of expansion possible,
% either expand until the key-macro or expand the key-macro once as well (the
% latter might break if the key-macros take additional arguments). The
% following supports both by using a starred form.
% \begin{macrocode}
\protected\long\def\ekvcompile
{%
\ekv@alignsafe
\ekv@ifstar{\ekv@compile{}}{\ekv@compile{\expandafter\expandafter}}%
}
% \end{macrocode}
% \begin{macro}[internal]
% {\ekv@compile,\ekv@compile@,\ekv@compile@key,\ekv@compile@pair}
% |\ekvparse| starts with an |\unexpanded| that we don't need. Hence we use a
% temporary definition to remove that. Else this is pretty straight forward.
% There is a minor indirection (the parsing step of |\ekv@compile|) which is
% necessary to grab any argument specification.
% \begin{macrocode}
\def\ekv@compile#1#2#3#{\ekv@compile@{#1}{#2#3}}
\def\ekv@compile@#1#2#3{#2#3}
\ekv@exparg{\protected\long\def\ekv@compile@#1#2#3#4}%
{%
\expandafter\ekv@expanded\expandafter
{%
\romannumeral\ekv@expargtwice{\ekv@zero\def\ekv@unexpanded{#2}}%
{%
\expandafter\ekv@compile@
\ekvparse
{\ekv@compile@key{#1}{#3}}%
{\ekv@compile@pair{#1}{#3}}%
{#4}%
}%
}%
\ekv@endalignsafe
}
% \end{macrocode}
% The compilation step just checks whether the keys are defined and leaves
% their code (maybe expanded once).
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@compile@key#1#2#3}%
{%
\ekvifdefinedNoVal{#2}{#3}%
{\ekv@unexpanded#1\expandafter{\csname\ekv@name{#2}{#3}N\endcsname}}%
{%
\ekv@ifdefined{\ekv@name{#2}{}uN}
{%
\ekv@unexpanded#1\expandafter
{%
\csname\ekv@name{#2}{}uN\expandafter\endcsname
\expandafter{\detokenize{#3}}{#3}%
}%
}%
{%
\ekvifdefined{#2}{#3}%
{\ekv@err{missing value for `#3' in set `#2'}}%
{\ekv@err{unknown key `#3' in set `#2'}}%
}%
}%
}
\ekv@exparg{\long\def\ekv@compile@pair#1#2#3#4}%
{%
\ekvifdefined{#2}{#3}%
{\ekv@unexpanded#1\expandafter{\csname\ekv@name{#2}{#3}\endcsname{#4}}}%
{%
\ekv@ifdefined{\ekv@name{#2}{}u}%
{%
\ekv@unexpanded#1\expandafter
{%
\csname\ekv@name{#2}{}u\ekv@expanded{\endcsname
{\ekv@unexpanded{#4}}{\detokenize{#3}}}{#3}%
}%
}%
{%
\ekvifdefinedNoVal{#2}{#3}%
{\ekv@err{unwanted value for `#3' in set `#2'}}%
{\ekv@err{unknown key `#3' in set `#2'}}%
}%
}%
}
% \end{macrocode}
% \end{macro}
% \end{macro}
%
% \begin{macro}{\ekverr}
% \begin{macro}[internal]{\ekv@err@collect,\ekv@err@cleanup}
% Since |\ekvset| is fully expandable as long as the code of the keys is (which
% is unlikely) we want to somehow throw expandable errors, in our case via
% a runaway argument (to my knowledge the first version of this method was
% implemented by Jean-François Burnol, many thanks to him). The first step is to
% ensure that the second argument (which might contain user input) doesn't
% contain tokens we use as delimiters (in this case |\par|), this will be done
% by the front facing macro |\ekverr|. But first we set some other things up.
%
% We use a temporary definition for |\ekverr| to get multiple consecutive
% spaces. Then we set up the macro that will collect the error and the macro
% that will throw the error. The latter will have an unreasonable long name.
% This way we can convey more information. Though the information in the macro
% name is static and has to be somewhat general to fit every occurence. The
% important bit is that the long named macro has a delimited argument and is
% short which will throw the error at the |\par| at the end of
% |\ekv@err@collect|. This macro has the drawback that it will only print nicely
% if the |\newlinechar| is |^^J|.
% \begin{macrocode}
\def\ekv@err@cleanup\par{}
\def\ekv@err@collect#1%
{%
\def\ekv@err@collect##1\par##2%
{%
\expandafter
\ekv@err@cleanup
#1! ##2 Error: ##1\par
}%
\def#1##1\thanks@jfbu{}%
}
\def\ekverr{ }
\expandafter\ekv@err@collect\csname <an-expandable-macro>^^J%
completed due to above exception. \ekverr If the error^^J%
summary is \ekverr not comprehensible \ekverr see the package^^J%
documentation.^^J%
I will try to recover now. \ekverr If you're in inter-^^J%
active mode hit <return> \ekverr at the ? prompt and I^^J%
continue hoping recovery\endcsname
% \end{macrocode}
% \begin{macrocode}
\long\def\ekverr#1#2{\expandafter\ekv@err@collect\detokenize{#2}\par{#1}}
% \end{macrocode}
% \end{macro}
% \end{macro}
%
% \begin{macro}[internal]{\ekv@err,\ekv@errm}
% We define shorthands to throw errors in \expkv.
% \begin{macrocode}
\ekv@exparg{\long\def\ekv@err#1}{\ekverr{expkv}{#1}}
\protected\long\def\ekv@errm#1{\errmessage{expkv Error: #1}}
% \end{macrocode}
% \end{macro}
%
% \begin{macro}[internal]
% {
% \ekv@err@common,\ekv@err@common@,
% \ekv@err@unknown,\ekv@err@noarg,\ekv@err@reqval,
% \ekv@err@undefined@expansion
% }
% Now we can use |\ekv@err| to set up some error messages so that we can later
% use those instead of the full strings.
% \begin{macrocode}
\long\def\ekv@err@common #1#2{\expandafter\ekv@err@common@\string#2{#1}}
\ekv@exparg{\long\def\ekv@err@common@#1`#2' #3.#4#5}%
{\ekv@err{#4 `#5' in set `#2'}}
\ekv@exparg{\long\def\ekv@err@unknown#1#2}{\ekv@err@common{unknown key}{#1}}
\ekv@exparg{\long\def\ekv@err@noarg#1#2}%
{\ekv@err@common{unwanted value for}{#1}}
\ekv@exparg{\long\def\ekv@err@reqval#1#2}%
{\ekv@err@common{missing value for}{#1}}
\ekv@exparg{\long\def\ekv@err@redirect@kv@notfound#1#2#3\ekv@stop}%
{\ekv@err{no key `#2' in sets #3}}
\ekv@exparg{\def\ekv@err@redirect@k@notfound#1#2\ekv@stop}%
{\ekv@err{no NoVal key `#1' in sets #2}}
\ekv@exparg{\def\ekv@err@undefined@expansion#1\fi}%
{\expandafter\fi\ekv@err{Undefined expansion rule `#1'}}
\ekv@exparg{\def\ekv@err@erroneous@variable#1}%
{\ekv@err{Erroneous variable `#1' used}}
\ekv@exparg{\def\ekv@err@key@no@reinsert}%
{\ekv@err{Reinsertion in \key expansion forbidden}}
\ekv@exparg{\def\ekv@err@val@no@reinsert#1}%
{\ekv@err{Reinsertion with key `#1' forbidden}}
% \end{macrocode}
% \end{macro}
%
% Now everything that's left is to reset the category code of |@|.
% \begin{macrocode}
\catcode`\@=\ekv@tmp
% \end{macrocode}
%
% \gobbledocstriptag
%</tex>
%^^A=<<