From b5a2e1693a20452ed082823402d3c619eebc6599 Mon Sep 17 00:00:00 2001 From: Norbert Preining Date: Sun, 5 Apr 2020 03:02:36 +0000 Subject: CTAN sync 202004050302 --- macros/generic/expkv-cs/expkv-cs.dtx | 1389 ++++++++++++++++++++++++++++++++++ 1 file changed, 1389 insertions(+) create mode 100644 macros/generic/expkv-cs/expkv-cs.dtx (limited to 'macros/generic/expkv-cs/expkv-cs.dtx') diff --git a/macros/generic/expkv-cs/expkv-cs.dtx b/macros/generic/expkv-cs/expkv-cs.dtx new file mode 100644 index 0000000000..88510651dc --- /dev/null +++ b/macros/generic/expkv-cs/expkv-cs.dtx @@ -0,0 +1,1389 @@ +% \iffalse meta-comment +% +% File: expkv-cs.dtx Copyright (C) 2020 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\nameofplainTeX{plain} +\ifx\fmtname\nameofplainTeX\else + \expandafter\begingroup +\fi +\input l3docstrip.tex +\askforoverwritefalse +\preamble + +-------------------------------------------------------------- +expkv-cs -- define expandable key=val macros using expkv +E-mail: jspratte@yahoo.de +Released under the LaTeX Project Public License v1.3c or later +See http://www.latex-project.org/lppl.txt +-------------------------------------------------------------- + +Copyright (C) 2020 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 + +This work is "maintained" (as per LPPL maintenance status) by + Jonathan P. Spratte. + +This work consists of the file expkv-cs.dtx +and the derived files expkv-cs.pdf + expkv-cs.sty + expkv-cs.tex + +\endpreamble +% stop docstrip adding \endinput +\postamble +\endpostamble +\generate{\file{expkv-cs.sty}{\from{expkv-cs.dtx}{pkg}}} +\generate{\file{expkv-cs.tex}{\from{expkv-cs.dtx}{tex}}} +\ifx\fmtname\nameofplainTeX + \expandafter\endbatchfile +\else + \expandafter\endgroup +\fi +% +\IfFileExists{expkv-cs.tex}{\input{expkv-cs.tex}}{} +\ProvidesFile{expkv-cs.dtx} + [\csname ekvcDate\endcsname\ define expandable key=val macros using expkv] +\PassOptionsToPackage{full}{textcomp} +\documentclass{l3doc} +\RequirePackage[oldstylenums,nott]{kpfonts} +\input{glyphtounicode} +\pdfgentounicode=1 +\RequirePackage{listings} +\RequirePackage{booktabs} +\RequirePackage{array} +\RequirePackage{collcell} +\RequirePackage{siunitx} +\RequirePackage{xcolor} +\RequirePackage{caption} +\RequirePackage{microtype} +\RequirePackage{accsupp} +\lstset + { + ,flexiblecolumns=false + ,basewidth=.53em + ,gobble=2 + ,basicstyle=\fontfamily{jkp}\itshape + ,morekeywords=^^A + {^^A + \ekvcSplit,\ekvcSplitAndForward, + \ekvcHash,\ekvcHashAndForward, + \ekvcValue,\ekvcValueFast, + \ekvcSecondaryKeys + } + ,morecomment=[l]\% + ,commentstyle=\color[gray]{0.4} + ,literate={\{}{{\CodeSymbol\{}}{1} + {\}}{{\CodeSymbol\}}}{1} + ^^A,literate=*{}{\key}{4}{}{\set}{4} + } +\newcommand*\CodeSymbol[1]{\textbf{#1}} +\RequirePackage{randtext} +\let\metaORIG\meta +\protected\def\meta #1{\texttt{\metaORIG{#1}}} +\renewcommand*\thefootnote{\fnsymbol{footnote}} +\definecolor{expkvred}{HTML}{9F393D} +\colorlet{expkvgrey}{black!75} +\makeatletter +\newcommand*\expkv + {^^A + \texorpdfstring + {^^A + \mbox + {^^A + \BeginAccSupp{ActualText=expkv}^^A + \href{https://github.com/Skillmon/tex_expkv} + {^^A + \rmfamily + \bfseries + {\color{expkvgrey}e\kern-.05em x\kern-.05em}^^A + \lower.493ex + \hbox{{\color{expkvgrey}P}\kern-.1em{\color{expkvred}k}}^^A + \kern-.18em{\color{expkvred}v}^^A + }^^A + \EndAccSupp{}^^A + }^^A + } + {expkv}^^A + } +\newcommand*\expkvpkg[1] + {^^A + \texorpdfstring + {^^A + \mbox + {^^A + \BeginAccSupp{ActualText=expkv-#1}^^A + \href{https://github.com/Skillmon/tex_expkv-#1} + {^^A + \rmfamily + \bfseries + {\color{expkvgrey}e\kern-.05em x\kern-.05em}^^A + \lower.493ex + \hbox{{\color{expkvgrey}P}\kern-.1em{\color{expkvred}k}}^^A + \kern-.18em{\color{expkvred}v}^^A + {\color{expkvgrey}^^A + \kern.05em\rule[-.1ex]{.08em}{1.2ex}\kern.05em\textsc{#1}^^A + }^^A + }^^A + \EndAccSupp{}^^A + }^^A + } + {expkv-#1}^^A + } +\newcommand*\expkvd{\expkvpkg{def}} +\newcommand*\expkvc{\expkvpkg{cs}} +\newcommand\kv{\meta{key}=\meta{value}} +\newcommand\key{\meta{key}} +\newcommand\val{\meta{value}} +\newcommand\set{\meta{set}} +\newcommand\enflong{\textcolor{black}{long}} +\newcommand\alllong{\textcolor{gray}{long}} +\newcommand\notlong{\textcolor{red!80!black}{long}} +\newcommand\prefixes[1] + {^^A + \hfill + \ifcase\numexpr#1\relax\or + \enflong\or + \alllong\or + \notlong\fi + } +\hypersetup{linkcolor=red!80!black,urlcolor=purple!80!black} +\DoNotIndex{\def,\edef,\,,\=,\begingroup,\catcode,\chardef,\csname,\endcsname} +\DoNotIndex{\endgroup,\endinput,\errmessage,\expandafter,\input,\let,\long} +\DoNotIndex{\protected,\ProvidesFile,\ProvidesPackage,\relax,\space,\advance} +\DoNotIndex{\@,\unexpanded,\string,\expanded,\dimexpr,\global,\glueexpr,\hbox} +\DoNotIndex{\numexpr,\RequirePackage,\setbox,\the,\unless,\xdef,\gdef,\newcount} +\DoNotIndex{\romannumeral,\^,\@firstofone,\@firstoftwo,\@gobble} +\DoNotIndex{\ifcsname} +\DoNotIndex{\ifx} +\DoNotIndex{\ifnum} +\DoNotIndex{\ifdefined} +\DoNotIndex{\iffalse} +\DoNotIndex{\iftrue} +\DoNotIndex{\else} +\DoNotIndex{\fi} +\@gobble\fi ^^A ignoring \ifx, \ifcsname, etc., but only one \fi +\@gobble\fi ^^A ignoring \ifx, \ifcsname, etc., but only one \fi +\@gobble\fi ^^A ignoring \ifx, \ifcsname, etc., but only one \fi +\@gobble\fi ^^A ignoring \ifx, \ifcsname, etc., but only one \fi +\@gobble\fi ^^A ignoring \ifx, \ifcsname, etc., but only one \fi +\@ifdefinable\gobbledocstriptag{\def\gobbledocstriptag#1>{}} +\makeatother +\begin{document} + \title + {^^A + \texorpdfstring + {^^A + \huge\expkvc + \\[\medskipamount] + \Large define expandable \kv\ macros using \expkv + }{expkv-cs - define expandable key=val macros using expkv}^^A + } + \date{\ekvcDate\space v\ekvcVersion} + \author{Jonathan P. Spratte\thanks{\protect\randomize{jspratte@yahoo.de}}} + \DocInput{expkv-cs.dtx} +\end{document} +%^^A=<< +% \fi +% +% \maketitle +% \renewcommand*\thefootnote{\arabic{footnote}} +% +% \begin{abstract} +% \noindent\parfillskip=0pt +% \expkvc\ provides two small interfaces to define expandable \kv\ macros +% utilizing \expkv. It therefore lowers the entrance boundary to expandable \kv\ +% macros. The stylised name is \expkvc\ but the files use +% \file{expkv-cs}, this is due to CTAN-rules which don't allow \string| in +% package names since that is the pipe symbol in *nix shells. +% \end{abstract} +% +% \tableofcontents +% +% \begin{documentation}^^A>>= +% +% \section{Documentation} +% +% The \expkv\ package enables the new possibility of creating \kv\ macros which +% are fully expandable. The creation of such macros is however cumbersome for +% the average user. \expkvc\ tries to step in here. It provides interfaces to +% define \kv\ macros without worrying too much about the implementation. There +% are two different approaches supported by this package. The first is splitting +% the keys up into individual arguments, the second is providing all the keys as +% a single argument to the underlying macro and getting an individual \val\ by +% using a hash. Well, actually there is no real hash, just some markers which +% are parsed, but this shouldn't be apparent to the user, the behaviour matches +% that of a hash-table. +% +% In addition to these two methods of defining a macro with primary keys a way +% to define secondary keys, which can reference the primary ones, is provided. +% These secondary keys don't correspond to an argument or an entry in the hash +% table directly but might come in handy for the average use case. Each macro +% has its own set of primary and secondary keys. +% +% A word of advice you should consider: If your macro doesn't have to be +% expandable (and often it doesn't) don't use \expkvc. The interface has some +% overhead (though it still can be considered fast) and the approach has its +% limits. If you don't need to be expandable, you should consider either +% defining your keys manually using \expkv\ or using \expkvd\ for convenience. +% Or you resort to another \kv\ interface. +% +% \expkvc\ is usable as generic code and as a \LaTeX\ package. It'll +% automatically load \expkv\ in the same mode as well. To use it, just use one +% of +% \begin{lstlisting} +% \usepackage{expkv-cs} % LaTeX +% \input expkv-cs % plainTeX +% \end{lstlisting} +% +% +% \subsection{Define Macros and Primary Keys} +% +% All macros defined with \expkvc\ have to be previously undefined or have the +% |\meaning| of |\relax|. This is necessary as there is no way to undefine keys +% once they are set up (neither \expkv\ nor \expkvc\ keep track of defined +% keys) -- so to make sure there are no conflicts only new definitions are +% allowed (that's not the case for individual keys, only for frontend macros). +% +% +% \subsubsection{Primary Keys}\label{sec:primaries} +% +% In the following descriptions there will be one argument named \meta{primary +% keys}. This argument should be a \kv\ list where each \key\ will be one +% primary key and \val\ the associated initial value. By default all keys are +% defined short, but you can define long keys by prefixing \key\ with |long| +% (\emph{e.g.}, \texttt{long name=Jonathan P. Spratte}). You only need |long| if +% the key should be able to take a |\par| token. Note however that |long| keys +% are a microscopic grain faster (due to some internals of \expkvc). Only if at +% least one of the keys was |long| the \meta{cs} in the following defining +% macros will be |\long|. For obvious reasons there is no possibility to define +% a macro or key as |\protected|. +% +% At the moment \expkvc\ doesn't require any internal keys, but I can't foresee +% whether this will be the case in the future as well, as it might turn out that +% some features I deem useful can't be implemented without such internal keys. +% Because of this, please don't use key names starting with +% \texttt{EKVC\string|} as that should be the private name space. +% +% +% \subsubsection{Split} +% +% The split variants will provide the key values as separate arguments. This +% limits the number of keys for which this is truly useful. +% +% \begin{function}{\ekvcSplit} +% \begin{syntax} +% \cs{ekvcSplit}\meta{cs}\marg{primary keys}\marg{definition} +% \end{syntax} +% This defines \meta{cs} to be a macro taking one mandatory argument which +% should contain a \kv\ list. The \meta{primary keys} will be defined for this +% macro (see \autoref{sec:primaries}). The \meta{definition} is the code that +% will be executed. You can access the \val\ of a \key\ by using a macro +% parameter from |#1| to |#9|. The order of the macro parameters will be the +% order provided in the \meta{primary keys} list (so |#1| is the \val\ of the +% key defined first). With |\ekvcSplit| you can define macros using at most +% nine primary keys. +% \end{function} +% +% \begin{function}{\ekvcSplitAndForward} +% \begin{syntax} +% \cs{ekvcSplit}\meta{cs_1}\meta{cs_2}\marg{primary keys} +% \end{syntax} +% This defines \meta{cs_1} to be a macro taking one mandatory argument which +% should contain a \kv\ list. You can use as many primary keys as you want +% with this. The primary keys will be forwarded to \meta{cs_2} as braced +% arguments (as many as necessary for your primary keys). The order of the +% braced arguments will be the order of your primary key definitions. +% \end{function} +% +% \subsubsection{Hash} +% +% The hash variants will provide the key values as a single argument in which +% you can access specific values using a special macro. The implementation might +% be more convenient and scale better, \emph{but} it is much slower (for a +% primitive macro with a single key benchmarking was almost $1.7$ times slower, +% the root of which being the key access with |\ekvcValue|, not the parsing, and +% for a key access using |\ekvcValueFast| it was still about $1.2$ times +% slower). So if your macro uses less than ten primary keys, you should most +% likely use the split approach. +% +% \begin{function}{\ekvcHash} +% \begin{syntax} +% \cs{ekvcHash}\meta{cs}\marg{primary keys}\marg{definition} +% \end{syntax} +% This defines \meta{cs} to be a macro taking one mandatory argument which +% should contain a \kv\ list. You can use as many primary keys as you want. +% The primary keys will be forwarded as a single argument containing every key +% to the underlying macro. The underlying macro is defined as +% \meta{definition}, in which you can access the \val\ of a \key\ by using +% \texttt{\cs[no-index]{ekvcValue}\{\key\}\{\#1\}}. +% \end{function} +% +% \begin{function}{\ekvcHashAndForward} +% \begin{syntax} +% \cs{ekvcHashAndForward}\meta{cs_1}\meta{cs_2}\marg{primary keys} +% \end{syntax} +% This defines \meta{cs_1} to be a macro taking one mandatory argument which +% should contain a \kv\ list. You can use as many primary keys as you want. +% The primary keys will be forwarded as a single argument containing every key +% to the underlying macro. For the underlying macro \meta{cs_2} is used (so +% this will provide the key list as a single argument to \meta{cs_2}). In the +% underlying macro you can access the \val\ of a \key\ by using +% \texttt{\cs[no-index]{ekvcValue}\{\key\}\{\#1\}}. +% \end{function} +% +% \begin{function}{\ekvcValue} +% \begin{syntax} +% \cs{ekvcValue}\{\key\}\marg{key list} +% \end{syntax} +% This is a safe (but slow) way to access your keys in a hash variant. \key\ +% is the key which's \val\ you want to use out of the \meta{key list}. +% \meta{key list} should be the key list argument forwarded to your underlying +% macro by |\ekvcHash| or |\ekvcHashAndForward|. It will be tested whether the +% hash function to access that \key\ exists, the \key\ argument is not empty, +% and that the \meta{key list} really contains a \val\ of that \key. This +% macro needs exactly two steps of expansion. +% \end{function} +% +% \begin{function}{\ekvcValueFast} +% \begin{syntax} +% \cs{ekvcValueFast}\{\key\}\marg{key list} +% \end{syntax} +% This behaves just like |\ekvcValue|, but \emph{without any} safety tests. As +% a result this is about $1.4$ times faster \emph{but} will throw low level +% \TeX\ errors eventually if the hash function isn't defined or the \key\ +% isn't part of the \meta{key list} (\emph{e.g.}, because it was defined as a +% key for another macro -- all macros share the same hash function per \key). +% Use it if you know what you're doing. This macro needs exactly three steps +% of expansion in the no-errors case. +% \end{function} +% +% +% \subsection{Secondary Keys} +% +% To remove some of the limitations with the approach that each primary key +% matches an argument or hash entry, you can define secondary keys. Those have +% to be defined for each macro but it doesn't matter whether that macro was a +% split or a hash variant. If a secondary key references another key it doesn't +% matter whether that other key is primary or secondary. +% +% Secondary keys can have a prefix (like |long|) which are called |p|-type +% prefix and must have a type (like |meta|) which are called |t|-type prefix. +% Some types might require some |p|-prefixes, while others might forbid those. +% +% Please keep in mind that key names shouldn't start with \texttt{EKVC\string|}. +% +% \begin{function}{\ekvcSecondaryKeys} +% \begin{syntax} +% \cs{ekvcSecondaryKeys}\meta{cs}\{\kv, \ldots\} +% \end{syntax} +% This is the front facing macro to define secondary keys. For the macro +% \meta{cs} define \key\ to have definition \val. The general syntax for \key\ +% should be +% \begin{quote}\ttfamily\small +% \meta{prefix} \meta{name} +% \end{quote} +% Where \meta{prefix} is a space separated list of optional |p|-type prefixes +% followed by one |t|-type prefix. The syntax of \val\ is dependent on the +% used |t|-prefix. +% \end{function} +% +% +% \subsubsection{\texttt{p}-type Prefixes} +% +% There is only one |p|-prefix available, which is |long|. +% +% \begin{function}{long} +% The following key will be defined |\long|. +% \end{function} +% +% +% \subsubsection{\texttt{t}-type Prefixes} +% +% If you're familiar with \expkvd\ you'll notice that the |t|-type prefixes +% provided here are much fewer. The expansion only concept doesn't allow for +% great variety in the auto-defined keys. +% +% The syntax examples of the |t|-prefixes will show which |p|-prefix will be +% automatically used by printing those black (\texttt{\enflong}), which +% will be available in grey (\texttt{\alllong}), and which will be disallowed in +% red (\texttt{\notlong}). This will be put flush right next to the syntax line. +% +% \begin{function}{meta} +% \begin{syntax} +% meta \key\ = \{\kv, \ldots\} \prefixes2 +% \end{syntax} +% With a |meta| key you can set other keys. Whenever \key\ is used the keys in +% the \kv\ list will be set to the values given there. You can use the \val\ +% given to \key\ by using |#1| in the \kv\ list. The keys in the \kv\ list can +% be primary and secondary ones. +% \end{function} +% +% \begin{function}{nmeta} +% \begin{syntax} +% nmeta \key\ = \{\kv, \ldots\} \prefixes3 +% \end{syntax} +% An |nmeta| key is like a |meta| key, but it doesn't take a value, so the +% \kv\ list is static. +% \end{function} +% +% \begin{function}{alias} +% \begin{syntax} +% alias \key\ = \meta{key_2} \prefixes3 +% \end{syntax} +% This assigns the definition of \meta{key_2} to \key. As a result \key\ is an +% alias for \meta{key_2} behaving just the same. Both the value taking and the +% |NoVal| version (that's \expkv\ slang for a key not accepting a value) will +% be copied if they are defined when |alias| is used. Of course, \meta{key_2} +% has to be defined, be it as a primary or secondary one. +% \end{function} +% +% \begin{function}{default} +% \begin{syntax} +% default \key\ = \marg{default} \prefixes3 +% \end{syntax} +% If \key\ is a defined value taking key, you can define a |NoVal| version +% with this that will behave as if \key\ was given \meta{default} as its +% \val. Note that this doesn't change the initial values of primary keys set +% at definition time in |\ekvcSplit| and friends. \key\ can be a primary or +% secondary key. +% \end{function} +% +% +% \subsection{Example} +% +% How could a documentation be a good documentation without some basic examples? +% Say we want to define a small macro expanding to some character description +% (who knows why this has to be expandable?). A character description will not +% have too many items to it, so we use |\ekvcSplit|. +% \begin{lstlisting} +% \ekvcSplit\character +% { +% name=John Doe, +% age=any, +% nationality=the Universe, +% hobby=to exist, +% type=Mister, +% pronoun=He, +% possessive=his, +% } +% {% +% #1 is a #5 from #3. #6 is of #2 age and #7 hobby is #4.\par +% } +% \end{lstlisting} +% Also we want to give some short cuts so that it's easier to describe several +% persons. +% \begin{lstlisting} +% \ekvcSecondaryKeys\character +% { +% alias pro = pronoun, +% alias pos = possessive, +% nmeta me = +% { +% name=Jonathan P. Spratte, +% age=a young, +% nationality=Germany, +% hobby=\TeX\ coding, +% }, +% meta lady = +% {type=Lady, pronoun=She, possessive=her, name=Jane Doe, #1}, +% nmeta paulo = +% { +% name=Paulo, +% type=duck, +% age=a young, +% nationality=Brazil, +% hobby=to quack, +% } +% } +% \end{lstlisting} +% Now we can describe people using +% \begin{lstlisting} +% \character{} +% \character{me} +% \character{paulo} +% \character +% {lady={name=Evelyn,nationality=Ireland,age=the best,hobby=reading}} +% \character +% { +% name=Our sun, type=star, nationality=our solar system, pro=It, +% age=an old, pos=its, hobby=shining +% } +% \end{lstlisting} +% As one might see, the |lady| key could actually have been an |nmeta| key as +% well, as all that is done with the argument is using it as a \kv\ list. +% +% Utilizing \pkg{xparse} and forwarding arguments one can easily define \kv\ +% macros with actual optional and mandatory arguments as well. A small nonsense +% example (which should perhaps use |\ekvcSplitAndForward| instead of +% |\ekvcHashAndForward| since it only uses four keys and one other argument -- +% and isn't expandable since it uses a \env{tabular} environment): +% \begin{lstlisting} +% \usepackage{xparse} +% \makeatletter +% \NewExpandableDocumentCommand\nonsense{O{} m}{\nonsense@a{#1}{#2}} +% \ekvcHashAndForward\nonsense@a\nonsense@b +% { +% keyA = A, +% keyB = B, +% keyC = c, +% keyD = d, +% } +% \newcommand*\nonsense@b[2] +% {% +% \begin{tabular}{lll} +% key & A & \ekvcValue{keyA}{#1} \\ +% & B & \ekvcValue{keyB}{#1} \\ +% & C & \ekvcValue{keyC}{#1} \\ +% & D & \ekvcValue{keyD}{#1} \\ +% \multicolumn{2}{l}{mandatory} & #2 \\ +% \end{tabular}\par +% } +% \makeatother +% \end{lstlisting} +% And then we would be able to do some nonsense: +% \begin{lstlisting} +% \nonsense{} +% \nonsense[keyA=hihi]{haha} +% \nonsense[keyA=hihi, keyB=A]{hehe} +% \nonsense[keyC=huhu, keyA=hihi, keyB=A]{haha} +% \end{lstlisting} +% +% +% \subsection{Useless Macros} +% +% Perhaps these macros aren't completely useless, but I figured from a user's +% point of view I wouldn't know what I should do with these. +% +% \begin{function}{\ekvcDate,\ekvcVersion} +% These two macros store the version and the date of the package/generic code. +% \end{function} +% +% +% \subsection{Bugs} +% +% Of course I don't think there are any bugs (who would knowingly distribute +% buggy software as long as he isn't a multi-million dollar corporation?). But +% if you find some please let me know. For this one might find my email address +% on the first page or file an issue on Github: +% \url{https://github.com/Skillmon/tex_expkv-cs} +% +% +% \subsection{License} +% +% Copyright \textcopyright\ 2020\unless\ifnum\year=2020--\the\year\fi\ +% Jonathan P. Spratte +% +% \medskip\noindent +% 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: +% +% \url{http://www.latex-project.org/lppl.txt} +% +% \noindent +% This work is ``maintained'' (as per LPPL maintenance status) by +% +% \mbox{Jonathan P. Spratte}. +% +% \end{documentation}^^A=<< +% +% \begin{implementation}^^A>>= +% +% \clearpage +% +% \section{Implementation}^^A>>= +%^^A the LaTeX package >>= +% \subsection{The \LaTeX\ Package} +% Just like for \expkv\ we provide a small \LaTeX\ package that sets up things +% such that we behave nicely on \LaTeX\ packages and files system. It'll +% |\input| the generic code which implements the functionality. +% \gobbledocstriptag +%<*pkg> +% \begin{macrocode} +\RequirePackage{expkv} +\def\ekvc@tmp + {% + \ProvidesFile{expkv-cs.tex}% + [% + \ekvcDate\space v\ekvcVersion\space + define expandable key=val macros using expkv% + ]% + } +\input{expkv-cs.tex} +\ProvidesPackage{expkv-cs}% + [% + \ekvcDate\space v\ekvcVersion\space + define expandable key=val macros using expkv% + ] +% \end{macrocode} +% \gobbledocstriptag +% +%^^A=<< +%^^A main file >>= +% \subsection{The Generic Code} +% The rest of this implementation will be the generic code. +% \gobbledocstriptag +%<*tex> +% +% Load \expkv\ if the package didn't already do so -- since \expkv\ has +% safeguards against being loaded twice this does no harm and the overhead +% isn't that big. Also we reuse some of the internals of \expkv\ to save us from +% retyping them. +% \begin{macrocode} +\input expkv +% \end{macrocode} +% +% We make sure that \file{expkv-cs.tex} is only input once: +% \begin{macrocode} +\expandafter\ifx\csname ekvcVersion\endcsname\relax +\else + \expandafter\endinput +\fi +% \end{macrocode} +% +% \begin{macro}{\ekvcVersion,\ekvcDate} +% We're on our first input, so lets store the version and date in a macro. +% \begin{macrocode} +\def\ekvcVersion{0.1} +\def\ekvcDate{2020-04-04} +% \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 |\ekvc@tmp| to use +% |\ProvidesFile|, else this will expand to a |\relax| and do no harm. +% \begin{macrocode} +\csname ekvc@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 ekvc@tmp\endcsname=\catcode`\@ +\catcode`\@=11 +% \end{macrocode} +% |\ekvc@tmp| will be reused later, but we don't need it to ever store +% information long-term after \expkvc\ was initialized. +% +% \begin{macro}[internal]{\ekvc@keycount} +% We'll need to keep count how many keys must be defined for each macro in the +% |split| variants. +% \begin{macrocode} +\newcount\ekvc@keycount +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@long,\ekvc@any@long} +% Some macros will have to be defined long. These two will be let to |\long| +% when this should be the case. +% \begin{macrocode} +\def\ekvc@long{} +\def\ekvc@any@long{} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ekvcSplitAndForward} +% The first user macro we want to set up can be reused for +% \cs[no-index]{ekvcSplit}. We'll split this one up so that the test whether +% the macro is already defined doesn't run twice. +% \begin{macrocode} +\protected\long\def\ekvcSplitAndForward#1#2#3% + {% + \ekv@ifdefined{\expandafter\@gobble\string#1}% + {\ekvc@err@already@defined{#1}}% + {\ekvcSplitAndForward@{#1}{#2}{#3}}% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvcSplitAndForward@} +% The actual macro setting up things. We need to set some variables, forward +% the key list to |\ekvc@SetupSplitKeys|, and afterwards define the front +% facing macro to call |\ekvset| and put the initials and the argument sorting +% macro behind it. The internals |\ekvc@any@long|, |\ekvc@initials| and +% |\ekvc@keycount| will be set correctly by |\ekvc@SetupSplitKeys|. +% \begin{macrocode} +\protected\long\def\ekvcSplitAndForward@#1#2#3% + {% + \edef\ekvc@set{\string#1}% + \ekvc@SetupSplitKeys{#3}% + \ekvc@any@long\edef#1##1% + {% + \unexpanded{\ekvset}{\ekvc@set}{##1}% + \unexpanded\expandafter + {\csname ekvc@split@\the\ekvc@keycount\endcsname}% + \unexpanded\expandafter{\ekvc@initials{}#2}% + }% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ekvcSplit} +% The first half is just |\ekvcSplitAndForward| then we define the macro to +% which the parsed key list is forwarded. There we need to allow for up to +% nine arguments. +% \begin{macrocode} +\protected\long\def\ekvcSplit#1#2#3% + {% + \ekv@ifdefined{\expandafter\@gobble\string#1}% + {\ekvc@err@already@defined{#1}}% + {% + \expandafter + \ekvcSplitAndForward@\expandafter#1\csname ekvc@\string#1\endcsname{#2}% + \ifnum\ekvc@keycount=0 + \def\ekvc@tmp##1##{}% + \else + \ifnum\ekvc@keycount>9 + \ekvc@err@toomany{#1}% + \ekvc@defarggobbler9% + \else + \expandafter\ekvc@defarggobbler\the\ekvc@keycount + \fi + \fi + \ekvc@any@long\expandafter + \def\csname ekvc@\string#1\expandafter\endcsname + \ekvc@tmp##1##2##3##4##5##6##7##8##9% + {#3}% + }% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal] +% { +% \ekvc@SetupSplitKeys, \ekvc@SetupSplitKeys@a, \ekvc@SetupSplitKeys@b, +% \ekvc@SetupSplitKeys@c +% } +% These macros parse the list of keys and set up the key macros. First we need +% to initialise some macros and start |\ekvparse|. +% \begin{macrocode} +\protected\long\def\ekvc@SetupSplitKeys#1% + {% + \ekvc@keycount=0 + \def\ekvc@any@long{}% + \def\ekvc@initials{}% + \ekvparse\ekvc@err@value@required\ekvc@SetupSplitKeys@a{#1}% + } +% \end{macrocode} +% Then we need to step the key counter for each key. Also we have to check +% whether this key has a |long| prefix so we initialise |\ekvc@long|. +% \begin{macrocode} +\protected\def\ekvc@SetupSplitKeys@a#1% + {% + \advance\ekvc@keycount1 + \def\ekvc@long{}% + \ekvc@ifspace{#1}% + {\ekvc@SetupSplitKeys@b#1\ekvc@stop}% + {\ekvc@SetupSplitKeys@c{#1}}% + } +% \end{macrocode} +% If there was a space, there might be a prefix. If so call the prefix macro, +% else call the next step |\ekvc@SetupSplitKeys@c| which will define the key +% macro and add the key's value to the initials list. +% \begin{macrocode} +\protected\def\ekvc@SetupSplitKeys@b#1 #2\ekvc@stop + {% + \ekv@ifdefined{ekvc@split@p@#1}% + {\csname ekvc@split@p@#1\endcsname{#2}}% + {\ekvc@SetupSplitKeys@c{#1 #2}}% + } +% \end{macrocode} +% The inner definition is grouped, because we don't want to actually define +% the marks we build with |\csname|. We have to append the value to the +% |\ekvc@initials| list here with the correct split mark. The key macro will +% read everything up to those split marks and change the value following it to +% the value given to the key. Additionally we'll need a sorting macro for each +% key count in use so we set it up with |\ekvc@setup@splitmacro|. +% \begin{macrocode} +\protected\long\def\ekvc@SetupSplitKeys@c#1#2% + {% + \begingroup + \edef\ekvc@tmp + {% + \endgroup + \long\def\unexpanded{\ekvc@tmp}####1####2% + \unexpanded\expandafter + {\csname ekvc@splitmark@\the\ekvc@keycount\endcsname}####3% + {% + ####2% + \unexpanded\expandafter + {\csname ekvc@splitmark@\the\ekvc@keycount\endcsname}{####1}% + }% +% \end{macrocode} +% The short variant needs a bit of special treatment. The key macro will be +% short to throw the correct error, but since there might be long macros +% somewhere the reordering of arguments needs to be long, so for short keys we +% use a two step approach, first grabbing only the short argument, then +% reordering. +% \begin{macrocode} + \unless\ifx\ekvc@long\long + \let\unexpanded\expandafter + {\csname ekvc@\ekvc@set(#1)\endcsname\ekvc@tmp}% + \def\unexpanded{\ekvc@tmp}####1% + {% + \unexpanded\expandafter{\csname ekvc@\ekvc@set(#1)\endcsname}% + {####1}% + }% + \fi + \def\unexpanded{\ekvc@initials}% + {% + \unexpanded\expandafter{\ekvc@initials}% + \unexpanded\expandafter + {\csname ekvc@splitmark@\the\ekvc@keycount\endcsname{#2}}% + }% + }% + \ekvc@tmp + \ekvlet\ekvc@set{#1}\ekvc@tmp + \expandafter\ekvc@setup@splitmacro\expandafter{\the\ekvc@keycount}% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@split@p@long} +% The |long| prefix lets the internals |\ekvc@long| and |\ekvc@any@long| to +% |\long| so that the key macro will be long. +% \begin{macrocode} +\protected\def\ekvc@split@p@long + {% + \let\ekvc@long\long + \let\ekvc@any@long\long + \ekvc@SetupSplitKeys@c + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@defarggobbler} +% This is needed to define a macro with 1-9 parameters programmatically. +% \LaTeX's \cs[no-index]{newcommand} does something similar for example. +% \begin{macrocode} +\protected\def\ekvc@defarggobbler#1{\def\ekvc@tmp##1#1##2##{##1#1}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@setup@splitmacro, \ekvc@split@1} +% Since the first split macro is different from the others we manually set +% that one up now. All the others will be defined as needed (always globally). +% The split macros just read up until the correct split mark, move that +% argument into a list and reinsert the rest, calling the next split macro +% afterwards. +% \begin{macrocode} +\begingroup +\edef\ekvc@tmp + {% + \long\gdef\unexpanded\expandafter{\csname ekvc@split@1\endcsname}% + \unexpanded\expandafter{\csname ekvc@splitmark@1\endcsname}% + ##1##2##3% + {##3{##1}##2}% + } +\ekvc@tmp +\endgroup +\protected\def\ekvc@setup@splitmacro#1% + {% + \ekv@ifdefined{ekvc@split@#1}{}% + {% + \begingroup + \edef\ekvc@tmp + {% + \long\gdef + \unexpanded\expandafter{\csname ekvc@split@#1\endcsname}% + ####1% + \unexpanded\expandafter{\csname ekvc@splitmark@#1\endcsname}% + ####2####3% + {% + \unexpanded\expandafter + {\csname ekvc@split@\the\numexpr#1-1\relax\endcsname}% + ####1{{####2}####3}% + }% + }% + \ekvc@tmp + \endgroup + }% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ekvcHashAndForward} +% |\ekvcHashAndForward| works just like |\ekvcSplitAndForward|. +% \begin{macrocode} +\protected\long\def\ekvcHashAndForward#1#2#3% + {% + \ekv@ifdefined{\expandafter\@gobble\string#1}% + {\ekvc@err@already@defined{#1}}% + {\ekvcHashAndForward@{#1}{#2}{#3}}% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvcHashAndForward@} +% This is more or less the same as |\ekvcHashAndForward@|. Instead of an empty +% group we place a marker after the initials, we don't use the sorting macros +% of |split|, but instead pack all the values in one argument. +% \begin{macrocode} +\protected\long\def\ekvcHashAndForward@#1#2#3% + {% + \edef\ekvc@set{\string#1}% + \ekvc@SetupHashKeys{#3}% + \ekvc@any@long\edef#1##1% + {% + \unexpanded{\ekvset}{\ekvc@set}{##1}% + \unexpanded{\ekvc@hash@pack@argument}% + \unexpanded\expandafter{\ekvc@initials\ekvc@stop#2}% + }% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ekvcHash} +% |\ekvcHash| does the same as |\ekvcSplit|, but has the advantage of not +% needing to count arguments, so the definition of the internal macro is a bit +% more straight forward. +% \begin{macrocode} +\protected\long\def\ekvcHash#1#2#3% + {% + \ekv@ifdefined{\expandafter\@gobble\string#1}% + {\ekvc@err@already@defined{#1}}% + {% + \expandafter + \ekvcHashAndForward@\expandafter#1\csname ekvc@\string#1\endcsname{#2}% + \ekvc@any@long\expandafter\def\csname ekvc@\string#1\endcsname##1{#3}% + }% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@hash@pack@argument} +% All this macro does is pack the values into one argument and forward that to +% the next macro. +% \begin{macrocode} +\long\def\ekvc@hash@pack@argument#1\ekvc@stop#2{#2{#1}} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal] +% {\ekvc@SetupHashKeys,\ekvc@SetupHashKeys@a,\ekvc@SetupHashKeys@b} +% This should look awfully familiar as well, since it's just the same as for +% the split keys with a few other names here and there. +% \begin{macrocode} +\protected\long\def\ekvc@SetupHashKeys#1% + {% + \def\ekvc@any@long{}% + \def\ekvc@initials{}% + \ekvparse\ekvc@err@value@required\ekvc@SetupHashKeys@a{#1}% + } +\protected\def\ekvc@SetupHashKeys@a#1% + {% + \def\ekvc@long{}% + \ekvc@ifspace{#1}% + {\ekvc@SetupHashKeys@b#1\ekvc@stop}% + {\ekvc@SetupHashKeys@c{#1}}% + } +\protected\def\ekvc@SetupHashKeys@b#1 #2\ekvc@stop + {% + \ekv@ifdefined{ekvc@hash@p@#1}% + {\csname ekvc@hash@p@#1\endcsname{#2}}% + {\ekvc@SetupHashKeys@c{#1 #2}}% + } +% \end{macrocode} +% Yes, even the defining macro looks awfully familiar. Instead of numbered we +% have named marks. Still the key macros grab everything up to their +% respective mark and reorder the arguments. The same quirk is applied for +% short keys. And instead of the |\ekvc@setup@splitmacro| we use +% |\ekvc@setup@hashmacro|. +% \begin{macrocode} +\protected\long\def\ekvc@SetupHashKeys@c#1#2% + {% + \begingroup + \edef\ekvc@tmp + {% + \endgroup + \long\def\unexpanded{\ekvc@tmp}####1####2% + \unexpanded\expandafter{\csname ekvc@hashmark@#1\endcsname}####3% + {% + ####2% + \unexpanded\expandafter{\csname ekvc@hashmark@#1\endcsname}{####1}% + }% + \unless\ifx\ekvc@long\long + \let\unexpanded\expandafter + {\csname ekvc@\ekvc@set(#1)\endcsname\ekvc@tmp}% + \def\unexpanded{\ekvc@tmp}####1% + {% + \unexpanded\expandafter{\csname ekvc@\ekvc@set(#1)\endcsname}% + {####1}% + }% + \fi + \def\unexpanded{\ekvc@initials}% + {% + \unexpanded\expandafter{\ekvc@initials}% + \unexpanded\expandafter{\csname ekvc@hashmark@#1\endcsname{#2}}% + }% + }% + \ekvc@tmp + \ekvlet\ekvc@set{#1}\ekvc@tmp + \ekvc@setup@hashmacro{#1}% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@hash@p@long} +% Nothing astonishing here either. +% \begin{macrocode} +\protected\def\ekvc@hash@p@long + {% + \let\ekvc@long\long + \let\ekvc@any@long\long + \ekvc@SetupHashKeys@c + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@setup@hashmacro} +% The safe hash macros will be executed inside of a |\romannumeral| expansion +% context, so they have to insert a stop mark for that once they are done. +% Most of the tests which have to be executed will already be done, but we +% have to play safe if the hash doesn't show up in the hash list. Therefore we +% use some |\ekvc@mark|s and |\ekvc@stop| to throw errors if the hash isn't +% found in the right place. The fast variants have an easier life and just +% return the correct value. +% \begin{macrocode} +\protected\def\ekvc@setup@hashmacro#1% + {% + \ekv@ifdefined{ekvc@hash@#1}{}% + {% + \begingroup + \edef\ekvc@tmp + {% + \long\gdef + \unexpanded\expandafter{\csname ekvc@fasthash@#1\endcsname}% + ####1% + \unexpanded\expandafter{\csname ekvc@hashmark@#1\endcsname}% + ####2####3\unexpanded{\ekvc@stop}% + {####2}% + \long\gdef + \unexpanded\expandafter{\csname ekvc@safehash@#1\endcsname}% + ####1% + {% + \unexpanded\expandafter{\csname ekvc@@safehash@#1\endcsname}% + ####1\unexpanded{\ekvc@mark}{ }% + \unexpanded\expandafter + {% + \csname ekvc@hashmark@#1\endcsname + {\ekvc@err@missing@hash{#1} }% + \ekvc@mark{}\ekvc@stop + }% + }% + \long\gdef + \unexpanded\expandafter{\csname ekvc@@safehash@#1\endcsname}% + ####1% + \unexpanded\expandafter{\csname ekvc@hashmark@#1\endcsname}% + ####2####3\unexpanded{\ekvc@mark}####4####5% + \unexpanded{\ekvc@stop}% + {% + ####4####2% + }% + }% + \ekvc@tmp + \endgroup + }% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ekvcValue} +% All this does is a few consistency checks on the first argument (not empty, +% hash macro exists) and then call that hash-grabbing macro that will also +% test whether the hash is inside of |#2| or not. +% \begin{macrocode} +\long\def\ekvcValue#1#2% + {% + \romannumeral`\^^@% + \ekv@ifdefined{ekvc@safehash@#1}% + {\csname ekvc@safehash@#1\endcsname{#2}}% + {\ekvc@err@unknown@hash{#1} }% keep this space + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ekvcValueFast} +% To be as fast as possible, this doesn't test for anything, assuming the user +% knows best. +% \begin{macrocode} +\long\def\ekvcValueFast#1#2{\csname ekvc@fasthash@#1\endcsname#2\ekvc@stop} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@safehash@,\ekvc@fasthash@} +% At least in the empty hash case we can provide a meaningful error message +% without affecting performance by just defining the macro that would be build +% in that case. There is of course a downside to this, the error will not be +% thrown by |\ekvcValueFast| in three expansion steps. The safe hash variant +% has to also stop the |\romannumeral| expansion. +% \begin{macrocode} +\long\def\ekvc@safehash@#1{\ekvc@err@empty@hash\@gobble{} }% keep this space +\long\def\ekvc@fasthash@#1\ekvc@stop{\ekvc@err@empty@hash} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\ekvcSecondaryKeys} +% The secondary keys are defined pretty similar to the way the originals are, +% but here we also introduce some key types (those have a |@t@| in their name) +% additionally to the prefixes. +% \begin{macrocode} +\protected\long\def\ekvcSecondaryKeys#1#2% + {% + \edef\ekvc@set{\string#1}% + \ekvparse\ekvc@err@value@required\ekvcSecondaryKeys@a{#2}% + } +\protected\def\ekvcSecondaryKeys@a#1% + {% + \def\ekvc@long{}% + \ekvc@ifspace{#1}% + {\ekvcSecondaryKeys@b#1\ekvc@stop}% + {\ekvc@err@missing@type{#1}\@gobble}% + } +\protected\def\ekvcSecondaryKeys@b#1 #2\ekvc@stop + {% + \ekv@ifdefined{ekvc@p@#1}% + {\csname ekvc@p@#1\endcsname}% + {% + \ekv@ifdefined{ekvc@t@#1}% + {\csname ekvc@t@#1\endcsname}% + {\ekvc@err@unknown@keytype{#1}\@firstoftwo\@gobble}% + }% + {#2}% + } +% \end{macrocode} +% \end{macro} +% +% +% \subsubsection{Secondary Key Types} +% +% \begin{macro}[internal]{\ekvc@p@long,\ekvc@after@ptype} +% The prefixes are pretty straight forward again. Just set |\ekvc@long| and +% forward to the |@t@| type. +% \begin{macrocode} +\protected\def\ekvc@p@long#1% + {% + \ekvc@ifspace{#1}% + {% + \let\ekvc@long\long + \ekvc@after@ptype#1\ekvc@stop + }% + {\ekvc@err@missing@type{long #1}\@gobble}% + } +\protected\def\ekvc@after@ptype#1 #2\ekvc@stop + {% + \ekv@ifdefined{ekvc@t@#1}% + {\csname ekvc@t@#1\endcsname{#2}}% + {\ekvc@err@unknown@keytype{#1}\@gobble}% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@t@meta, \ekvc@t@nmeta, \ekvc@type@meta} +% The |meta| and |nmeta| key types use a nested |\ekvset| to set other keys in +% the same macro's \set. +% \begin{macrocode} +\protected\def\ekvc@t@meta + {% + \edef\ekvc@tmp{\ekvc@set}% + \expandafter\ekvc@type@meta\expandafter{\ekvc@tmp}\ekvc@long{##1}\ekvlet + } +\protected\def\ekvc@t@nmeta#1% + {% + \ekvc@assert@not@long{nmeta #1}% + \edef\ekvc@tmp{\ekvc@set}% + \expandafter\ekvc@type@meta\expandafter{\ekvc@tmp}{}{}\ekvletNoVal{#1}% + } +\protected\long\def\ekvc@type@meta#1#2#3#4#5#6% + {% + #2\def\ekvc@tmp#3{\ekvset{#1}{#6}}% + #4\ekvc@set{#5}\ekvc@tmp + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@t@alias} +% |alias| just checks whether there is a key and/or |NoVal| key defined with +% the target name and |\let| the key to those. +% \begin{macrocode} +\protected\def\ekvc@t@alias#1#2% + {% + \ekvc@assert@not@long{alias #1}% + \let\ekvc@tmp\@firstofone + \ekvifdefined\ekvc@set{#2}% + {% + \ekvletkv\ekvc@set{#1}\ekvc@set{#2}% + \let\ekvc@tmp\@gobble + }% + {}% + \ekvifdefinedNoVal\ekvc@set{#2}% + {% + \ekvletkvNoVal\ekvc@set{#1}\ekvc@set{#2}% + \let\ekvc@tmp\@gobble + }% + {}% + \ekvc@tmp{\ekvc@err@unknown@key{#2}}% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@t@default} +% The |default| key can be used to set a |NoVal| key for an existing key. It +% will just pass the \val\ to the key macro of that other key. +% \begin{macrocode} +\protected\long\def\ekvc@t@default#1#2% + {% + \ekvifdefined\ekvc@set{#1}% + {% + \ekvc@assert@not@long{default #1}% + \edef\ekvc@tmp + {% + \unexpanded\expandafter + {\csname\ekv@name\ekvc@set{#1}\endcsname{#2}}% + }% + \ekvletNoVal\ekvc@set{#1}\ekvc@tmp + }% + {\ekvc@err@unknown@key{#1}}% + } +% \end{macrocode} +% \end{macro} +% +% +% \subsubsection{Helper Macros} +% +% \begin{macro}[internal]{\ekvc@ifspace,\ekvc@ifspace@} +% A test which can be reduced to an if-empty by gobbling everything up to the +% first space. +% \begin{macrocode} +\long\def\ekvc@ifspace#1% + {% + \ekvc@ifspace@#1 \ekv@ifempty@B + \ekv@ifempty@false\ekv@ifempty@A\ekv@ifempty@B\@firstoftwo + } +\long\def\ekvc@ifspace@#1 % keep this space + {% + \ekv@ifempty@\ekv@ifempty@A + } +% \end{macrocode} +% \end{macro} +% +% +% \subsubsection{Assertions} +% \begin{macro}[internal]{\ekvc@assert@not@long} +% Some keys don't want to be |long| and we have to educate the user, so let's +% throw an error if someone wanted these to be long. +% \begin{macrocode} +\long\def\ekvc@assert@not@long#1{\ifx\ekvc@long\long\ekvc@err@no@long{#1}\fi} +% \end{macrocode} +% \end{macro} +% +% +% \subsubsection{Messages} +% +% \begin{macro}[internal] +% { +% \ekvc@err@toomany,\ekvc@err@value@required,\ekvc@err@missing@type, +% \ekvc@err@already@defined +% } +% Boring unexpandable error messages. +% \begin{macrocode} +\protected\def\ekvc@err@toomany#1% + {% + \errmessage{expkv-cs Error: Too many keys for macro `\string#1'}% + } +\protected\def\ekvc@err@value@required#1% + {% + \errmessage{expkv-cs Error: Missing value for key `\unexpanded{#1}'}% + } +\protected\def\ekvc@err@missing@type#1% + {% + \errmessage + {expkv-cs Error: Missing type for secondary key `\unexpanded{#1}'}% + } +\protected\def\ekvc@err@no@long#1% + {% + \errmessage + {expkv-cs Error: prefix `long' not accepted for `\unexpanded{#1}'}% + } +\protected\def\ekvc@err@already@defined#1% + {% + \errmessage{expkv-cs Error: Macro `\string#1' already defined}% + } +\protected\def\ekvc@err@unknown@keytype#1% + {% + \errmessage{expkv-cs Error: Unknown key type `\unexpanded{#1}'}% + } +\protected\def\ekvc@err@unknown@key#1% + {% + \errmessage + {expkv-cs Error: Unknown key `\unexpanded{#1}' for macro `\ekvc@set'}% + } +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal]{\ekvc@err,\ekvc@err@} +% We need a way to throw error messages expandably in some contexts. +% \begin{macrocode} +\begingroup +\edef\ekvc@err + {% + \endgroup + \unexpanded{\long\def\ekvc@err}##1% + {% + \unexpanded{\expandafter\ekvc@err@\@firstofone}% + {\unexpanded\expandafter{\csname ! expkv-cs Error:\endcsname}##1.}% + \unexpanded{\ekv@stop}% + }% + } +\ekvc@err +\def\ekvc@err@{\expandafter\ekv@gobbleto@stop} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}[internal] +% {\ekvc@err@unknown@hash,\ekvc@err@empty@hash,\ekvc@err@missing@hash} +% And here are the expandable error messages. +% \begin{macrocode} +\long\def\ekvc@err@unknown@hash#1{\ekvc@err{unknown hash `#1'}} +\long\def\ekvc@err@missing@hash#1{\ekvc@err{hash `#1' not found}} +\long\def\ekvc@err@empty@hash{\ekvc@err{empty hash}} +% \end{macrocode} +% \end{macro} +% +% +% Now everything that's left is to reset the category code of |@|. +% \begin{macrocode} +\catcode`\@=\ekvc@tmp +% \end{macrocode} +% +% \gobbledocstriptag +% +%^^A=<< +% +%^^A=<< +% +% \end{implementation}^^A=<< +% +% \clearpage +% \PrintIndex +% +\endinput +% +^^A vim: ft=tex fdm=marker fmr=>>=,=<< -- cgit v1.2.3