summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/source/latex/xpackages/xbase
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2009-09-06 23:20:42 +0000
committerKarl Berry <karl@freefriends.org>2009-09-06 23:20:42 +0000
commitbfb16a7c8d3c77987590435854c647b54bc6450b (patch)
treecf65fafece2986d781a52ad28aaeb06fe48eed69 /Master/texmf-dist/source/latex/xpackages/xbase
parent2b8eb47b09b2d853b8243d0fb61b408edb3d04a7 (diff)
xpackages (5sep09)
git-svn-id: svn://tug.org/texlive/trunk@15164 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Master/texmf-dist/source/latex/xpackages/xbase')
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/ldcsetup.dtx331
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/template-test.tex77
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/template-test2.tex110
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/template.dtx2452
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/tprestrict-test.tex80
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/xbase.ins73
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/xparse-test.tex296
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/xparse.dtx2443
8 files changed, 5862 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/ldcsetup.dtx b/Master/texmf-dist/source/latex/xpackages/xbase/ldcsetup.dtx
new file mode 100644
index 00000000000..09e37c55cb3
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/ldcsetup.dtx
@@ -0,0 +1,331 @@
+% \iffalse
+%% File: ldcsetup.dtx (C) Copyright 1999 Frank Mittelbach, Chris Rowley, David Carlisle
+%% (C) Copyright 2004-2009 Frank Mittelbach, LaTeX3 Project
+%%
+%% It 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%<*driver|package>
+\RequirePackage{expl3}
+%</driver|package>
+%\fi
+\GetIdInfo$Id: ldcsetup.dtx 1295 2009-05-06 08:32:25Z will $
+ {coding conventions and stuff}
+%\iffalse
+%<*driver>
+%\fi
+\ProvidesFile{\filename.\filenameext}
+ [\filedate\space v\fileversion\space\filedescription]
+%\iffalse
+\documentclass{ltxdoc}
+\begin{document}
+\DocInput{ldcsetup.dtx}
+\end{document}
+%</driver>
+% \fi
+%
+% \CheckSum{0}
+%
+% \title{The \textsf{ldcsetup} package\thanks{This file
+% has version number \fileversion, last
+% revised \filedate.}}
+% \author{DPC, FMi}
+% \date{\filedate}
+% \maketitle
+%
+% \begin{abstract}
+% Basic code shared by several other packages currently under development.
+% \end{abstract}
+%
+% \StopEventually{}
+%
+% \begin{macrocode}
+%<*package>
+\ProvidesExplPackage
+ {\filename}{\filedate}{\fileversion}{\filedescription}
+% \end{macrocode}
+% \begin{macrocode}
+\RequirePackage{keyval}
+\RequirePackage{expl3}
+\ExplSyntaxOff
+% \end{macrocode}
+%
+% \section{Ignoring White Space}
+% Within a package, or in a document preamble, you can use
+% |\IgnoreWhiteSpace| this makes white space ignored, and |@|
+% a letter, and |~| a space character. It lasts until the end of the
+% current package or preamble.
+%
+%% Puts an ignored space at the end of the line, so `|\ |' does the right
+% thing. (Perhaps should instead just change catcode of |^^M|)
+% \begin{macrocode}
+\def\IgnoreWhiteSpace{%
+ \edef\@tempa{%
+ \catcode`\noexpand\~=\the\catcode`\~\relax
+ \catcode`\noexpand\ =\the\catcode`\ \relax
+ \catcode`\noexpand\^^I=\the\catcode`\^^I\relax
+ \catcode`\noexpand\@=\the\catcode`\@\relax
+ \endlinechar=\the\endlinechar\relax
+ }%
+ \ifx\@currname\@empty
+ \expandafter\AtBeginDocument\expandafter{\@tempa}%
+ \else
+ \expandafter\AtEndOfPackage\expandafter{\@tempa}%
+ \fi
+ \catcode`\~=10\relax
+ \catcode`\ =9\relax
+ \catcode`\^^I=9\relax
+ \makeatletter
+ \endlinechar=` %
+ \relax
+}
+% \end{macrocode}
+% The new syntax requires |:| and |_| to be letters; instead of
+% putting that into |\IgnoreWhiteSpace| we make a new command which
+% helps to gradually change packages from old to new syntax.
+% \begin{macrocode}
+\def\InternalSyntaxOn{%
+ \edef\@tempa{%
+ \catcode`\noexpand\~=\the\catcode`\~\relax
+ \catcode`\noexpand\ =\the\catcode`\ \relax
+ \catcode`\noexpand\^^I=\the\catcode`\^^I\relax
+ \catcode`\noexpand\@=\the\catcode`\@\relax
+ \catcode`\noexpand\:=\the\catcode`\:\relax
+ \catcode`\noexpand\_=\the\catcode`\_\relax
+ \endlinechar=\the\endlinechar\relax
+%FMi fix is not properly reset
+ \endlinechar=13\relax
+ }%
+%%% ????
+% this needs further work, don't think it is working
+ \ifx\InternalSyntaxOff\relax
+ \expandafter\def\expandafter\InternalSyntaxOff\expandafter
+ {\@tempa\let\InternalSyntaxOff\relax}%
+ \fi
+ \ifx\@currname\@empty
+ \expandafter\AtBeginDocument\expandafter{\@tempa}%
+ \else
+ \expandafter\AtEndOfPackage\expandafter{\@tempa}%
+ \fi
+ \catcode`\~=10\relax
+ \catcode`\ =9\relax
+ \catcode`\^^I=9\relax
+ \makeatletter
+ \catcode`\_=11\relax
+ \catcode`\:=11\relax
+ \endlinechar=` %
+ \relax
+}
+\let\InternalSyntaxOff\relax
+% \end{macrocode}
+%
+% Do it for this package.
+% \begin{macrocode}
+%\InternalSyntaxOn
+\ExplSyntaxOn
+% \end{macrocode}
+%
+% \section{KV fixes}
+% Allow\footnote{Not needed now?} key names to start with |\|.
+% \begin{macrocode}
+\cs_set_nopar:Npn \define@key#1#2{%
+ \@ifnextchar[
+ {\KV@def{#1}{\string#2}}
+ {\@namedef{KV@#1@\string#2}####1}}
+\cs_set_nopar:Npn \setkeys#1#2{%
+ \cs_set_nopar:Npn \KV@prefix{KV@#1@\expandafter\string}%
+ \KV@do#2,\relax,}
+% \end{macrocode}
+%
+% Make KV |#| safe.
+% \begin{macrocode}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\newtoks\KV@toks
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@@sp@c#1\@nil#2\relax#3{\KV@toks{#1}\cs_set_nopar:Npx #3{\the\KV@toks}}
+% \end{macrocode}
+%
+% Generate error messages on missing `,'.
+%
+% More exactly if two `=' appear after a key generate an error.
+% The current KV just silently ignores everything after the second `='.
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@equal{=}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@split#1=#2=#3\relax{%
+ \KV@@sp@def\@tempa{#1}%
+ \cs_set_nopar:Npn \@tempd{#3}%
+ \ifx\@tempa\@empty\else
+ \expandafter\cs_set_eq:NN \expandafter\@tempc
+ \csname\KV@prefix\@tempa\endcsname
+ \ifx\@tempc\relax
+ \KV@error{\@tempa\space \expandafter\@gobbletwo\string\@undefined}\@eha
+ \else
+ \ifx\@tempd\@empty
+ \KV@default
+ \else
+ \KV@@sp@def\@tempb{#2}%
+ \ifx\@tempd\KV@equal
+ \expandafter\@tempc\expandafter{\@tempb}\relax
+ \else
+ \KV@error{Extra~=~ sign~ after~ `#1'}\KV@erry
+ \fi
+ \fi
+ \fi
+ \fi}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@erry{\expandafter\KV@errx\meaning\@tempd\relax ignored\MessageBreak
+ missing~comma~in~`\expandafter\strip@prefix\meaning\@tempb'~?}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@errx#1>#2==\relax{%
+ `#2' }
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@default{%
+ \expandafter\cs_set_eq:NN \expandafter\@tempb
+ \csname\KV@prefix\@tempa @default\endcsname
+ \ifx\@tempb\relax
+ \KV@error{No value specified for \@tempa}\@eha
+ \else
+ \@tempb\relax
+ \fi}
+% \end{macrocode}
+%
+% \LaTeX\ style error message.
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@error#1#2{\PackageError{keyval}{#1}{#2}}
+% \end{macrocode}
+%
+% Instead of doing a full KV parse, and evaluating all the keys,
+% you might want to parse a parameter list, even for undefined keys,
+% removing spaces, splitting up the `,` and `=' and resolving cases
+% where no value is supplied. This is used in |\DeclareGenericFunction|
+% which \emph{defines} a set of keys via such a KV parse.
+%
+% A setting of |, key = value ,| will result in |\KV@elt{key}{value}|
+% being added to the list, a seting of |, key ,| will result in
+% |\KV@default@elt{key}| being added. At the end of the parse the list
+% is executed. No keys are checked at this stage (so no csnames are used
+% up) the two |\KV|\ldots|@elt| commands must be defined as appropriate.
+%
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@parse#1{
+ \begingroup
+% \end{macrocode}
+%
+% Locally fudge |\KV@@def| to just add to a token register
+% rather than make a definition.
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@@sp@c##1\@nil##2\relax##3{\addto@hook##3{{##1}}}
+% \end{macrocode}
+%
+% Locally fudge |\KV@split| to just add to a token register
+% rather than execute the code for the found keys.
+% \begin{macrocode}
+\cs_set_nopar:Npn \KV@split##1=##2=##3\relax{%
+ \cs_set_nopar:Npn \@tempd{##3}%
+ \expandafter\ifx\expandafter=\@firstofone##1=\else
+ \ifx\@tempd\@empty
+ \addto@hook\KV@toks\KV@default@elt
+ \KV@@sp@def\KV@toks{##1}%
+ \else
+ \ifx\@tempd\KV@equal
+ \addto@hook\KV@toks\KV@elt
+ \KV@@sp@def\KV@toks{##1}%
+ \KV@@sp@def\KV@toks{##2}%
+ \else
+ \KV@err{Extra `=' after `##1'}\@ehd
+ \fi
+ \fi
+ \fi}
+% \end{macrocode}
+%
+% Initialise
+% \begin{macrocode}
+ \KV@toks{}
+% \end{macrocode}
+% Do the parse
+% \begin{macrocode}
+ \KV@do#1,\relax,
+% \end{macrocode}
+% Evaluate the token register outside the group.
+% \begin{macrocode}
+ \expandafter
+ \endgroup
+ \the\KV@toks}
+% \end{macrocode}
+%
+% \section{Calc fixes}
+%
+% Count Register assignments via calc. Here we also provide some
+% global versions since a normal global prefix won't have any effect.
+% \begin{macrocode}
+\cs_set_eq:NN \SetInternalCounter \calc_int_set:Nn
+\cs_set_eq:NN \GSetInternalCounter\calc_int_gset:Nn
+% \end{macrocode}
+%
+%
+% \section{Misc code that is best collected in one place}
+%
+% This section will receive odd code that would be of potential use to
+% other packages and should eventually made it to the kernel
+% (perhaps).
+%
+% \begin{macro}{\UndeclareRobustCommand}
+% Remove a robust command from memory if it isn't used any
+% longer. Of course this doesn't free the hash table but at least
+% the space gets reclaimed.
+% \begin{macrocode}
+\cs_set_nopar:Npn \UndeclareRobustCommand#1{%
+ \cs_gundefine:N #1
+ \exp_args:Nc \cs_gundefine:N {\cs_to_str:N #1~}
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macrocode}
+%</package>
+% \end{macrocode}
+%
+% \Finale
+%
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/template-test.tex b/Master/texmf-dist/source/latex/xpackages/xbase/template-test.tex
new file mode 100644
index 00000000000..f8c47c82d59
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/template-test.tex
@@ -0,0 +1,77 @@
+% \iffalse
+%% (C) Copyright 2000-2004 LaTeX3 Project
+%%
+%% It may be distributed and/or modified under the conditions of the
+%% LaTeX Project Public License (LPPL), either version 1.3a 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% $Id: template-test.tex 251 2004-11-11 19:01:16Z mittelba $
+%%
+% \fi
+%
+\RequirePackage{template}
+
+\DeclareTemplateType{xxx}{0}
+
+\DeclareTemplate{xxx}{test}{0}
+ {
+ xkey=n \xkey,
+ key =i {yyy} \value
+ }
+ {
+ \DoParameterAssignments
+ \show\xkey
+ \show\value
+ \value
+ }
+
+\DeclareTemplateType{yyy}{0}
+
+\DeclareTemplate{yyy}{foo}{0}
+ {
+ keya =L \foo
+ }
+ {
+ \DoParameterAssignments
+ \show\foo
+ }
+
+
+\DeclareInstance{xxx}{bar}{test}
+ {
+ xkey = \UseTemplate{yyy}{foo}{ keya = 20pt },
+ key = \UseTemplate{yyy}{foo}{ keya = 10pt }
+ }
+
+\ShowInstance{xxx}{bar}
+
+\UseInstance{xxx}{bar}
+
+\stop
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/template-test2.tex b/Master/texmf-dist/source/latex/xpackages/xbase/template-test2.tex
new file mode 100644
index 00000000000..489e9f2304a
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/template-test2.tex
@@ -0,0 +1,110 @@
+% \iffalse
+%% (C) Copyright 2000-2004 LaTeX3 Project
+%%
+%% It may be distributed and/or modified under the conditions of the
+%% LaTeX Project Public License (LPPL), either version 1.3a 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% $Id: template-test2.tex 585 2006-12-12 17:31:48Z morten $
+%%
+% \fi
+%
+
+
+\RequirePackage{template}
+\RequirePackage{trace}
+
+\DeclareTemplateType{xxx}{0}
+
+\def\MultiSelection{\MultiSelectionError}
+%\def\foo{bar}
+
+%\traceon
+
+\DeclareTemplate{xxx}{test}{0}
+ {
+ xkey=n [\foo] \xkey,
+ ykey=n [\DelayEvaluation\foo] \ykey,
+ zkey=n \zkey,
+ last=n [last] \lastkey,
+ set =i {xxx} \xxx
+ }
+ {
+ \DoParameterAssignments
+ \typeout{abc}
+ }
+\ShowTemplate{xxx}{test}
+
+
+\DeclareInstance{xxx}{bar}{test}
+ {
+ zkey = foo,
+ xkey = baz,
+ }
+
+\DeclareInstance{xxx}{baz}{test}
+ {
+ last = first,
+ set = \UseTemplate{xxx}{test}{zkey=rrr},
+ zkey = foo
+ }
+
+
+\ShowInstance{xxx}{bar}
+\ShowInstance{xxx}{baz}
+
+\DeclareTemplateType{yyy}{0}
+
+\DeclareTemplate{yyy}{foo}{0}
+ {
+ keya =L \foo
+ }
+ {
+ \DoParameterAssignments
+ \show\foo
+ }
+
+
+\DeclareInstance{xxx}{bar}{test}
+ {
+ xkey = \UseTemplate{yyy}{foo}{ keya = 20pt },
+ key = \UseTemplate{yyy}{foo}{ keya = 10pt }
+ }
+
+\ShowInstance{xxx}{bar}
+
+\UseInstance{xxx}{bar}
+
+\stop
+
+%%% Local Variables:
+%%% mode: plain-tex
+%%% TeX-master: t
+%%% End:
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/template.dtx b/Master/texmf-dist/source/latex/xpackages/xbase/template.dtx
new file mode 100644
index 00000000000..8b38f6d216c
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/template.dtx
@@ -0,0 +1,2452 @@
+% \iffalse
+%% File: template.dtx (C) Copyright 1999-2001 David Carlisle, Frank Mittelbach
+%% (C) Copyright 2004-2009 Frank Mittelbach, LaTeX3 Project
+%%
+%% It 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%<*driver|package>
+\RequirePackage{expl3}
+%</driver|package>
+%\fi
+\GetIdInfo$Id: template.dtx 1461 2009-08-15 08:38:12Z joseph $
+ {template}
+%\iffalse
+%<*driver>
+%\fi
+\ProvidesFile{\filename.\filenameext}
+ [\filedate\space v\fileversion\space\filedescription]
+%\iffalse
+\documentclass{ltxdoc}
+\makeatletter
+ \newenvironment{decl}[1][]%
+ {\par\small\addvspace{4.5ex plus 1ex}%
+ \vskip -\parskip
+ \ifx\relax#1\relax
+ \def\@decl@date{}%
+ \else
+ \def\@decl@date{\NEWfeature{#1}}%
+ \fi
+ \noindent\hspace{-\leftmargini}%
+ \begin{tabular}{|l|}\hline\ignorespaces}%
+ {\\\hline\end{tabular}\nobreak\@decl@date\par\nobreak
+ \vspace{2.3ex}\vskip -\parskip\@afterheading}
+\makeatother
+
+ \begin{document}
+ \catcode`\_=11
+ \catcode`\:=11
+ \DocInput{template.dtx}
+ \end{document}
+%</driver>
+%
+%
+% \fi
+%
+%
+% \CheckSum{0}
+%
+% \title{The \textsf{template} package\thanks{This file
+% has version number \fileversion, last
+% revised \filedate.}}
+% \author{DPC, FMi}
+% \date{\filedate}
+% \maketitle
+%
+% \changes{0.06}{1998/12/17}{generic functions reborn as templates}
+%
+% \tableofcontents
+%
+% \section{Introduction}
+% A \emph{Template} is a named `function' that has a fixed number
+% of \emph{mandatory arguments} and an additional set of \emph{keys}
+% or `named attributes' that are set in a `key value list'. That is,
+% a comma separated set of assignments of the form:\\
+% \meta{key$_1$} |=| \meta{value$_1$} |,|
+% \meta{key$_2$} |=| \meta{value$_2$} \ldots
+%
+% More specific instances of the template may be declared by
+% specifying settings of the parameters. The key value list is parsed
+% at the time the instance is declared, and an `internal' set of
+% parameter assignments is passed to the template code. It is normally
+% not parsed at run-time, though it is possible to enforce this
+% behaviour.
+%
+% Templates have a \emph{type} and a \emph{name}. Templates
+% of the same type have the same argument and parameter
+% structure. That is, templates of the same type are expected to be
+% exchangeable semantically. (However, except for checking that
+% templates of the same type always have the same number of arguments
+% this is not enforced by the code.)
+%
+% A template type is declared via the |\DeclareTemplateType|
+% declaration which takes two arguments: the name for the type and the
+% number of arguments a template of this type requires.
+%
+% Templates are declared via the |\DeclareTemplate|
+% command which takes five arguments
+% \begin{itemize}
+% \item The \emph{type} of the template (no |\|).
+% \item The \emph{name} of the template (no |\|).
+% \item The number of arguments for the template (same as on type
+% declaration).
+% \item A list declaring the keys accepted by the template,
+% with information about the action to take when the key is specified
+% with a value.
+% \item The code for the template. This may be arbitrary \TeX\
+% code. At some point it should execute |\DoParameterAssignments|
+% to run the parameter assigments.
+%
+% The mandatory arguments are accessed via |#1|, |#2|, \ldots
+% \end{itemize}
+%
+%
+% Each element of the key specification list is of the form:
+% \begin{flushleft}
+% \meta{key name} |=|
+% \meta{key type} \meta{optional default} \meta{internal code}
+% \end{flushleft}
+%
+% The \meta{key types} are essentially specified by giving a symbolic
+% representation of the assignment function to be used by \TeX.
+%
+% Currently the possibilities are
+%
+% \begin{center}\catcode`|=12
+% \begin{tabular}{l|ll|l}
+% key type& letter& internal code& argument form\\\hline
+% Command & f\emph{n}&command name & command definition\\
+% name & n & command name & command definition\\
+% length & l & length register& calc length syntax\\
+% fake length & L & command name & calc length syntax\\
+% count & c & count register& calc count syntax\\
+% fake count & C & command name & calc count syntax\\
+% boolean & b & name of \verb|\newif| switch& true or false\\
+% switch & s & \marg{true code}\marg{false code}& true or false\\
+% instance& i\marg{type}& command name& instance of this \emph{type}\\
+% direct & x & Internal code& any\\
+% general & g & general code & any
+% \end{tabular}
+% \end{center}
+%
+% In addition, any of these types may be prefixed by |+| to
+% denote a global assignment (described below).
+% |f| takes a digit from 0--9 to denote the number of arguments.
+% |n| is in fact the same as |f0|. When an instance is declared
+% The value assigned to the key should be the definition of
+% the command, using |#1|\ldots|#9| to denote the specified arguments.
+%
+% |c| takes an internal form a count register,
+% not a \LaTeX\ counter name.
+%
+% For |f|, |n|, |l|, and |c|, the assignment is done twice, once
+% at the time an instance is \emph{declared}. (This may involve
+% using \textsf{calc} expresions. Then the `primitive assignment'
+% of the value (not using calc) is copied to the internal parameter
+% list, to be executed when an instance is run. Sometimes you need the
+% expression to be evaluated at the time an instance is run rather
+% than the time it is declared. For example it may be an expression
+% involving some values that are not fixed throughout a document.
+% In this case the instance declaration may give a value in the
+% form |\DelayedEvaluation|\marg{calc expression}. In this case
+% the value is not evaluated when the instance is declared, and
+% instead the entire expression is copied to the `internal parameter
+% list' and is evaluated whenever the instance is used.
+%
+% |L| and |C| take the same value types as |l| and |c| but the internal
+% assignments are to macros not registers.
+%
+% Keys declared with |b| and |s| each take values either \emph{true} or
+% \emph{false}. if the key zzz is declared with |b| then specifying
+% |zzz=true| will essentially pass |\zzztrue| to the internal parameter
+% list (although in fact |\zzztrue| need not be defined) . If instead
+% zzz had been declared via |s|, then |zzz=true| would pass the tokens
+% of the \marg{true code} to the internal parameter list.
+%
+% If a key is specified as |x|, then when used the \emph{internal code}
+% will be copied to the internal parameter lists. This code may use |#1|
+% to denote the value supplied to the key in the instance declaration.
+% Note that this code is \emph{only} copied at the time the instance is
+% declared. It is not executed at this time. It is executed when the
+% instance is executed.\footnote{Despite the question of whether or
+% not x and g are still necessary these days, they have the wrong
+% `names' since x is the one that is not executed during delcaration
+% while g is.}
+%
+% If a key is declared with |g| then the code is run at the time the
+% instance is declared. By default \emph{nothing} is passed to the
+% internal parameter list. This code may use |#1| to denote the
+% value that will be supplied when an instance is declared.
+% Any code that should be run when an instance is executed should
+% be explicitly passed to the internal parameter list using
+% |\toks_add_right:Nn\l_TP_KV_assignments_toks{|\ldots|}|
+%
+% A key declared with |i|\marg{type} takes as value the name of a
+% declared instance of that type. The command token associated with
+% the key will store a command essentially equivalent to a call
+% to |\UseInstance|\marg{type}\marg{name}, but in a slightly optimised
+% internal form.
+% As an exception to this rule the replacement code may be of the form
+% |\UseTemplate| followed by the key settings for the template
+% but without the mandatory arguments. In this case the `inner'
+% instance declaration is `pre compiled' and the token assigned to
+% the store the value assigned to this key will execute an instance
+% of the template directly, it will not re-parse the keyword settings
+% each time the instance is used.
+%
+% \section{Commands}
+%
+%
+% \subsection{Template declaration commands}
+%
+% \begin{decl}
+% |\DeclareTemplateType| \marg{type}\marg{num}
+% \end{decl}
+% Declare a template type.
+%
+% \begin{decl}
+% |\DeclareTemplate|
+% \marg{type}\marg{tname}\marg{num}\marg{keyspec}\marg{code}
+% \end{decl}
+% Declare a template \meta{tname} of type \meta{type} with the set of
+% keys as defined by \meta{keyspec}. From this template instances can
+% be declared using |\DeclareInstance| At runtime such instances will run
+% \meta{code} and expect \meta{num} mandatory arguments (same number
+% for all templates of one type).\footnote{The \meta{num} argument is
+% redundent as it can be deduced from the type. However, for practical
+% reasons it seems better to keep that information with each
+% individual template declaration.}
+%
+% \begin{decl}
+% |\DeclareRestrictedTemplate|
+% \marg{type}\marg{new-tname}\marg{old-tname}\marg{keyvals}
+% \end{decl}
+% Declare as new template \meta{new-tname} for type \meta{type} by
+% taking template \meta{old-tname} as the basis and setting one or
+% more of its keys to specific values.
+%
+% \begin{decl}
+% |\DoParameterAssignments|
+% \end{decl}
+% The list of key value assignments made (and saved) during template
+% declaration is evaluated at this point in the template code.
+%
+%
+% \subsection{Instance declaration commands}
+%
+% \begin{decl}
+% |\DeclareInstance| \marg{type}\marg{iname}\marg{tname}\marg{keyvals}
+% \end{decl}
+% Declare an instance of type \meta{type} named \meta{iname} build
+% from using template \meta{tname} with key settings as given by
+% \meta{keyvals}.
+%
+% \begin{decl}
+% |\DeclareCollectionInstance|
+% \marg{collection}\marg{type}\marg{iname}\marg{tname}\marg{keyvals}
+% \end{decl}
+% Same as |\DeclareInstance| except that this instance is only active
+% when for the type \meta{type} the collection \meta{collection} was
+% selected via |\UseCollection|. E.g., within the frontmatter one
+% could make all headings behave differently by defining collection
+% instances for template type `head'.
+%
+% \subsection{Key value commands}
+%
+% \begin{decl}
+% |\DelayEvaluation|\marg{code}
+% \end{decl}
+% Used in the value spec for an instance to declare that the value
+% \meta{code} should not be evaluated at declaration time but at
+% run-time. Can also be used in the defaults for keys (given in square
+% brackets) in the declaration of templates.
+%
+% \begin{decl}
+% |\MultiSelection| \meta{counter} \marg{cases} \marg{else}
+% \end{decl}
+% Used in the value spec for an instance key to declare that the value of
+% this key depends on the current setting of \meta{counter} at run-time.
+% The \meta{cases} argument is a comma-separated list of ``values'',
+% the \meta{else} argument a single ``value''. If at run-time
+% \meta{counter} has the value $i$ then the $i$-th element of the
+% \meta{cases} list is selected. If that does not exist the
+% \meta{else} case is returned.
+%
+%
+% \subsection{Processing commands}
+%
+% \begin{decl}
+% |\UseTemplate| \marg{type}\marg{tname}\marg{keyval}
+% \end{decl}
+% Execute a template \meta{tname} of type \meta{type} at run-time
+% using \meta{keyvals} as the value assignments for its keys. In this
+% case the keys are evaluated at run-time thus this method is far
+% slower than using a predeclared instance of this template (see
+% below). This command can also appear as the value for a key of type
+% `i' in which case the evaluation happens at declaration time of the
+% template that contains this key!
+%
+%
+% \begin{decl}
+% |\UseInstance| \marg{type}\marg{iname}
+% \end{decl}
+% Run the instance \meta{iname} of template type \meta{type}. If a
+% collection is in force see if there is a collection instance of name
+% \meta{iname} and if so run that instead.
+%
+% \begin{decl}
+% |\UseCollection| \marg{type}\marg{collection}
+% \end{decl}
+% Declare that from now on (normal scoping rules) the collection
+% \meta{collection} for template type \meta{type} is in force. This
+% means that a call to |\UseInstance| will first check if there is a
+% collection instance defined, and if so use that instance, otherwise
+% use the normal instance.
+%
+%
+% \subsection{Test commands}
+%
+% \begin{decl}
+% |\IfExistsInstanceTF| \marg{type}\marg{iname}\marg{true}\marg{false}
+% \end{decl}
+% Test if for template type \meta{type} an instance with name
+% \meta{iname} exists. Select \meta{true} or \meta{false} code
+% accordingly.
+%
+%
+%
+% \section{Examples of template key types}
+%
+% The general syntax for key specification in templates (fourth argument
+% of the command |\DeclareTemplate|) is:
+%\begin{flushleft}
+%| {| \\
+%| | \meta{key-name$_1$} |=|\meta{key-type$_1$}
+% \meta{optional-default$_1$} \meta{storage-bin$_1$}|,|\\
+%| | \meta{key-name$_2$} |=|\meta{key-type$_2$}
+% \meta{optional-default$_2$} \meta{storage-bin$_2$}|,|\\
+%| ...|\\
+%| }|
+%\end{flushleft}
+% In this section we look at all possible key types and give examples
+% for them.
+%
+%
+% \subsection{Attributes that receive names as values}
+%
+% The type |n| expects to receive a \LaTeX{} name as a value. Used,
+% for example, to specify the name of a \LaTeX{} counter to use.
+%\begin{verbatim}
+% heading-id =n \heading@id,
+% counter-id =n [\DelayEvaluation{\heading@id}] \heading@counter,
+%\end{verbatim}
+% Notice the use of |\DelayEvaluation| in the default of
+% |counter-id|. It is necessary to make the default the token
+% |\heading@id| if we want to inherit the value from the |heading-id|
+% key. Otherwise it gets value of |\heading@id| at the time the
+% instance is declared.
+%
+%
+% \subsection{Attributes that receive functions as values}
+%
+%
+% The type |f|\meta{num} expects a function with \meta{num} arguments
+% as a value. The arguments are denoted by |#1|, |#2|, etc. In most
+% cases either |f0| (for declarations) or |f1| (to format one argument) are
+% needed.
+%\begin{verbatim}
+% initial-font =f0 \initial@font,
+% initial-format =f1 [#1] \initial@boxhandling,
+%\end{verbatim}
+%
+% \subsection{Attributes that receive dimensions as values}
+%
+% As far as specifying instances the |l| and |L| type behave
+% identically. They differ only in the type of internal storage-bin
+% they need: |l| expects a length register while |L| expects an
+% ordinary macro name and assigns its value via |\cs_set_nopar:Npn |.
+%\begin{verbatim}
+% pre-sep =l \topsep,
+% post-sep =L \botsep,
+%\end{verbatim}
+%
+%
+%
+% \subsection{Attributes that receive integers as values}
+%
+% The |c| and |C| type receive integers as values. Again either of
+% them can be transparently used. In case of |c| the
+% \meta{storage-bin} has to be a \TeX{} count register not a \LaTeX{}
+% counter name, i.e., set up via |\newcount|. (\LaTeX{} counters can
+% be used as well if they are accessed via their internal name, i.e.,
+% via |\c@|\meta{\LaTeX-counter})
+%\begin{verbatim}
+% pre-penalty =c \@beginparpenalty,
+% penalty =C \hmaterial@penalty,
+%\end{verbatim}
+%
+%
+%
+% \subsection{Attributes that receive template instances as values}
+%
+% The type |i|\marg{type} takes as value the name of a declared
+% instance of that type. The \meta{storage-bin} associated with the
+% key will store a command essentially equivalent to a call to
+% |\UseInstance|\marg{type}\marg{name}, but in a slightly optimised
+% internal form.
+%
+% As an exception to this rule the replacement code may be of the form
+% |\UseTemplate| followed by the key settings for the template but
+% without the mandatory arguments. In this case the `inner' instance
+% declaration is `pre compiled' and the token assigned to the store
+% the value assigned to this key will execute an instance of the
+% template directly, it will not re-parse the keyword settings each
+% time the instance is used.
+%\begin{verbatim}
+% justification-setup =i{justification} \list@justification,
+%\end{verbatim}
+%
+% Usage within an instance declaration is either
+%\begin{verbatim}
+% justification-setup = raggedright,
+%\end{verbatim}
+% i.e., name of a declared instance or a call to |\UseTemplate|
+%\begin{verbatim}
+% justification-setup = \UseTemplate{justification}{TeX}
+% { startskip = 0pt, ... },
+%\end{verbatim}
+%
+%
+%
+% \subsection{Attributes that receive true or false values}
+%
+% The type |s| expects the strings |true| or |false| as values. In
+% this case the declaration has no \meta{storage-bin}. Instead the
+% declaration consists of two brace groups containing code. Depending
+% on the value one of the groups gets copied verbatim into the
+% internal parameter list of the instance and gets executed at
+% run-time at the point where |\DoParameterAssignments| is seen.
+%\begin{verbatim}
+% item-implicit-boolean =s
+% { \cs_set_nopar:Npn \item@implicit@code{\item\relax} }{},
+% numbered-boolean =b [true] @heading@nums,
+%\end{verbatim}
+%
+%
+% \subsection{Attributes that accept any value}
+%
+% The type |g| is a low-level specification which contains arbitrary
+% code in place of the \meta{storage-bin}. This code is evaluated at
+% declaration time of the instance and by default \emph{nothing} is
+% passed to the internal parameter list (this has to happen explicitly
+% from within the code). |#1| may be used to access the value
+% specified.
+%
+% The main purpose for this type is of historical nature (originally
+% most of the other types have been implemented internally using |g|).
+%
+% The type |x| also requires code in place of the \meta{storage-bin}.
+% However with this type all of the code is copied unevaluated to the
+% internal parameter list. There are some applications for this type
+% when implementing customisable defaults. However, it is likely that
+% it will not survive a final release.
+%\begin{verbatim}
+% generic-key =g \typeout{#1},
+% extra-assigns =x \typeout{#1},
+%\end{verbatim}
+%
+%
+%
+%
+%
+%
+% \section{A complete example}
+%
+% The following example shows a sketch of a template for typesetting
+% captions to be used as part of a larger mechanism setting whole
+% floats.\footnote{I made it up while I went along so if you spot the
+% ``missing brace'' or some other blunder tell me, FMi.}
+%
+% We declare a template type \texttt{caption} then define an example
+% template for that type and finally produce some instances from that.
+%
+% \subsection{Declaring the template type}
+%
+% To define the template type we first have to ask ourselves what
+% information would be varying each time such a template is used? A
+% potential answer could be the following:
+% \begin{itemize}
+% \item
+% The float name, e.g., `Table' or `Fig.' etc.
+% \item
+% The float
+% number e.g., `10' or `3--c' etc.
+% \item
+% The actual caption text as specified in the document.
+% \end{itemize}
+% Since the above items would be differed in each instantiation of
+% such a template we would pass them as mandatory argument to the
+% template.
+%
+% Are there others? Possibly. Here are two more that seem to be
+% useful, at least in a number of cases:
+% \begin{itemize}
+% \item
+% The text of the legend in document classes that distinguish
+% between caption text (heading to the figure/table) and legend
+% (explanatory material)
+% \item
+% Measure to which the caption should be typeset.
+% \end{itemize}
+% The last one of these might need some extra explanation. Suppose a
+% design requires that the caption width is decided depending on the
+% width of the table of figure, e.g., the caption is supposed to
+% typeset below some illustration and should not be wider than that
+% illustration, or the caption is typeset aside to the illustration
+% using the remaining space. In that case the process that formats the
+% whole float needs to communicate with the current template to pass
+% that (varying) information along. Of course, that could happen by
+% using global variables, e.g., the outer process sets the measure as
+% desired before calling the caption formatting template. What makes
+% more sense is likely to be a matter of taste but it also has to do
+% with the precise semantics of the template type. Staying with our
+% example: if the the semantics of the template type \texttt{caption}
+% is supposed to produce a formatted box (in \TeX{} terms) then we
+% should pass the measure as an argument if we ever intend to allow
+% for variations. If on the other hand the semantics are to format a
+% certain set of text into the current galley (which has measure of
+% its own) then a measure argument would not belong to this template
+% type.
+%
+% Are there other variations sensible? Yes, for example, instead of
+% passing a fixed string like ``Fig.'' as the first argument one could
+% pass an abstract float type identifier and let the template worry to
+% deduce from that information what fixed string to produce.
+%
+% Another question: why should we pass the fixed text (or an abstract
+% identifier from which it can be deduced) and the number as separate
+% arguments to the template instead of passing a combined string (like
+% it is done in the |\@makecaption| command of \LaTeXe{})? Answer:
+% because this allows to build templates that can individually
+% manipulate both bits of information, e.g., to format the number in a
+% different font, etc.
+%
+% So what are the conclusions of this discussion? Defining the
+% semantics of a template type is difficult and often needs several
+% trials to come up with something that is covering the anticipated
+% use. There is clearly not a cardinal way for defining template
+% types; how the overall separation into smaller units is done is
+% partly a matter of taste and partly a matter of the major layout
+% characteristics that one tries to support.
+%
+% Returning to our example: let's assume we settle for the first four
+% arguments, i.e., the calling template is responsible for setting the
+% measure for the caption text if necessary.
+%
+% What we also have to do is to define (at least for ourselves) what
+% data the arguments accept and what their semantics are. An informal
+% summary of that could be the following:
+% \begin{center}
+% \begin{tabular}{rrl}
+% \textit{Arg} & \textit{Data Type} & \textit{Description} \\[3pt]
+% 1 & text & fixed float description
+% \\
+% 2 & text/|\NoValue| & float number
+% \\
+% 3 & text & caption text
+% \\
+% 4 & text/|\NoValue| & legend text
+% \\
+% \end{tabular}
+% \end{center}
+% The second and the fourth argument are allowed to be missing (i.e.,
+% can get |\NoValue| passed as a value). Note that the empty string in
+% case of a text argument is different from |\NoValue|.
+%
+% We further declare that it is permissible for a template of this
+% type to ignore the information provided by all arguments except 3,
+% i.e., the caption text.
+%
+% Finally the result of the template formatting should is to typeset
+% text into a current galley (paragraph mode in \LaTeX{} lingua).
+%
+% All the above is semantic information that (at least right now) is
+% not being enforced by declaring a template type (except for the
+% number of arguments) but each template of a certain type is supposed
+% to conform to this specification nonetheless.\footnote{To make this
+% even clearer we are thinking of extending the template type
+% declaration with another argument in which one has to formally or
+% informally (?) specifies information like the one in the table
+% above.}
+%
+% This finally leads to the following declaration:
+%\begin{verbatim}
+%\DeclareTemplateType{caption}{4}
+%\end{verbatim}
+%
+% \subsection{Defining a first template}
+%
+% We start by defining a simple template of type \texttt{caption}
+% which roughly formats a caption like those being presented in
+% \LaTeXe{}'s article class, i.e., the caption is typeset as a
+% paragraph if it is longer than a single line, otherwise it is
+% centered. The legend even if present is ignored. Above and below we
+% give the designer the possibility to add some space.
+%
+% In fact the examples is more or less identical in code to
+% |\@makecaption| except that if the second argument (i.e., the
+% number) is |\NoValue| it and its preceding space\footnote{For those
+% who wonder: spaces are by default ignored within definitions when
+% the new packages are used due to a command \texttt{\textbackslash
+% InternalSyntaxOn}, do get a normal space one has to use
+% \texttt{\textasciitilde} and to obtain an unbreakable space
+% \texttt{\textbackslash nobreakspace}.} gets ignored.
+%
+% We start by declaring the template \texttt{toosimple} of type
+% \texttt{caption} having four mandatory arguments (as described in
+% the discussion of the template type).
+%\begin{verbatim}
+%\DeclareTemplate{caption}{toosimple}{4}
+%\end{verbatim}
+% The next argument of |\DeclareTemplate| lists all keys for the
+% template. In this case we have keys for the vertical spaces above
+% and below. We make them type |L| to save on registers but with a bit
+% of care we could also have used scratch registers like |\@tempskipa|
+% etc. Their default values are both zero.
+%\begin{verbatim}
+% {
+% above-skip =L [0pt] \caption@above@skip ,
+% below-skip =L [0pt] \caption@below@skip ,
+% }
+%\end{verbatim}
+% The final argument of |\DeclareTemplate| contains the actual
+% processing code. We start with looking at the second mandatory
+% argument (caption number) to find out if it is |\NoValue| and
+% depending on the result define a helper command |\caption@start|.
+%\begin{verbatim}
+% {
+% \IfNoValueTF{#2}
+% { \cs_set_nopar:Npn \caption@start{#1:~} }
+% { \cs_set_nopar:Npn \caption@start{#1~#2:~} }
+%\end{verbatim}
+% Having dealt with the prelims we now run |\DoParameterAssigments| at
+% which point the keys of the template are made available, e.g., at
+% this point all those right hand containers such as
+% |\caption@above@skip| get assigned the value specified in an
+% instantiation of the template. (That scheme allows to do preliminary
+% processing up front, e.g., defaults for the keys could be assigned
+% prior to that point in which case they are overwritten if the
+% template instance specifies a different value. the use of specifying
+% defaults via the |[..]| syntax as done above is slightly faster at
+% run-time but needs more memory.)
+%\begin{verbatim}
+% \DoParameterAssigments
+%\end{verbatim}
+% The rest of the code should look familiar to anybody who ever looked
+% at \texttt{article.cls}. The only point worth mentioning are the
+% |\relax| commands after |\caption@above@skip| and
+% |\caption@below@skip|. Since we have decided to use |L| as key type
+% these commands are macros and not registers containing the
+% dimensions as strings. This means that we have to be careful to
+% ensure that \TeX{} knows where the dimension ends. In certain cases
+% text following such a command might be mistaken as being part of the
+% dimension (e.g., if followed by the word \texttt{plus}, etc.). In
+% the code below this could only happen for the second |\vskip| but it
+% is good practice to always add a terminating |\relax| to avoid such
+% hidden traps.
+%\begin{verbatim}
+% \vskip \caption@above@skip \relax
+% \sbox \@tempboxa {\caption@start #3}
+% \ifdim \wd\@tempboxa >\hsize
+% \caption@start #3\par
+% \else
+% \global \@minipagefalse
+% \hb@xt@\hsize{\hfil\box\@tempboxa\hfil}
+% \fi
+% \vskip \caption@below@skip \relax
+% }
+%\end{verbatim}
+%
+% Why is the above template of not much use? Simply because it doesn't
+% offer any flexibility to declare different designs. The only
+% alteration offered to the designer is to modify the space above and
+% below the caption, e.g., the following declaration would mimic the
+% definition within the \texttt{article.cls} class of \LaTeXe :
+%\begin{verbatim}
+%\DeclareInstance{caption}{article}{toosimple}
+% {
+% above-skip = 0pt,
+% below-skip = 10pt,
+% }
+%\end{verbatim}
+% And that's all that can be manipulated. All items that people asking
+% to change, e.g., not having a colon after the number, using
+% different fonts and font sizes, etc.\ are still hard-wired and thus
+% inaccessible. So we have to do better if we want to make use of the
+% power the template mechanism offers.
+%
+%
+%
+% \subsection{Defining a better template}
+%
+% First step in defining better templates is to ask ourselves a couple
+% of questions:
+% \begin{itemize}
+% \item What are the main characteristics of the layout the template
+% is supposed to support?
+% \item What are the elements that we want to allow (or can allow) the
+% designer to modify?
+% \end{itemize}
+%
+% Take the first question first: the layout supported by the template
+% of the previous section had as its main characteristics that it
+% would center the caption if it would fit in a single line in the
+% current measure. We could consider this being an unchangable
+% characteristic of the layout this template produces (and a designer
+% would need to use a different template of type \texttt{caption} if a
+% design compatible with this restriction is desired) or we could try
+% to make our template smarter by adding bells and wistles that allow
+% the designer to say stuff like:
+%\begin{verbatim}
+% one-line-format = \hfil #1 \hfil,
+%\end{verbatim}
+% or
+%\begin{verbatim}
+% one-line-action = center,
+%\end{verbatim}
+% depending on how we intend to offer changing the behavior of the
+% template. Like when trying to define sensible template types we have
+% no single road to heaven (and probably as many to hell) --- it has a
+% lot to do with how we think about design.
+%
+% My advice, after having tried to work with these concepts for a
+% while, is to keep templates simple in so far as that most of not all
+% attribute for a template should be relevant for the design. In other
+% words, if you have attributes that, depending on their setting, make
+% half of the other attributes not applicable then it may be
+% appropriate to think about providing several templates instead. To
+% give an example from \LaTeXe : instead of having |\@startsection|
+% deal with both vertical heads and run-in heads provide individual
+% templates. (|\@startsection| is this famous command where design
+% switches are build in by making dimensions negative to signal
+% something and afterwards use the absolute value.)
+% Another way to look at this is to say that a template should
+% normally not contain large amounts of code which is only selected in
+% a subset of attribute settings.
+%
+% As said before there are no golden rules, it is perfectly possible
+% to make hugely complicated templates that solve every possible
+% aspect of layout one could think of in one go --- it is just that
+% with keeping it more simple one can get the same functionality with
+% less headaches for the template writer as well as the template user
+% later on.
+%
+% Returning to our example: allowing to handle the case of a single
+% line caption specially could well be considered part of the
+% template. In contrast: layouts that would put the caption number
+% sideways, i.e., which would need totally different internal coding
+% should probably be coded as a separate template of type
+% \texttt{caption}.
+%
+% So for our next example template we settle for the fixed caption
+% text plus number (if any) being at the beginning of the variable
+% caption text (coming from the document) and being together formatted
+% as some sort of a pargraph. In case of the whole caption being a
+% single line we allow the designer to specify how to lay it out
+% (e.g., centered, flush left, etc.). If there is a legend it will get
+% formatted by a vertical space followed by the legend formatted as
+% another paragraph.
+%
+% More precisely we allow for the following bells and wistles:
+%\begin{verbatim}
+%\DeclareTemplate{caption}{lesssimple}{4}
+% {
+%\end{verbatim}
+% The designer can specify the space above and below the caption like
+% we did in our first example.
+%\begin{verbatim}
+% above-skip =L [0pt] \caption@above@skip ,
+% below-skip =L [0pt] \caption@below@skip ,
+%\end{verbatim}
+% Regarding the caption number we support the case where no number is
+% present (the value being |\NoValue|) as well as the number being
+% present. For both cases the designer has to specify what formatting
+% should be attached. By default all is being typeset in the font the
+% whole caption is presented but if there is a need for it the
+% designer can use the following keys to attach special formatting
+% devices to each particular item beside specifying special spacing
+% information or replacing the default colon after the number with
+% something else.
+%\begin{verbatim}
+% number-format =f2 [#1~#2:~] \caption@number@format,
+% nonumber-format =f1 [#1:~] \caption@nonumber@format,
+%\end{verbatim}
+% If the caption is fitting onto a single line we make it possible
+% for the designer to specify how this single line should be
+% positioned (the default is to center the line).
+%\begin{verbatim}
+% single-line-format =f1 [\hfil#1\hfil] \caption@single@line@format,
+%\end{verbatim}
+% The font for the caption (including the fixed text and the number
+% unless specified differently above) is going to be the one decided
+% by the next key.
+%\begin{verbatim}
+% caption-font =f0 [\normalfont] \caption@font,
+%\end{verbatim}
+% The next attribute deserves some extra explanation: here we make use
+% of an interface which is explained in more detail when we reveil the
+% support for galley formatting.\footnote{Guess I have to apologize
+% for the fact that i partly make use of that interface in this
+% example while on other occasions (like the use of vertical spacing)
+% within the example I do not---consistency around midnight is not my
+% strength I fear (FMi).} In a nutshell the template type \texttt{hj}
+% (hyphenation \& justification) allows one to define a) the
+% justification concepts applied to the upcoming paragraphs, e.g.,
+% whether they should be set flush left, adjusted, first line
+% centered, etc.\ b) the linebreaking strategy used and c) the
+% hyphenation rules which should apply. All this is done by selecting
+% an appropriate (predefined) instance of this type as will hopefully
+% become somewhat clearer in the example instances shown below.
+%\begin{verbatim}
+% caption-hj-setup =i {hj} [default] \caption@hj@instance,
+%\end{verbatim}
+% In case there is a legend to format we give the designer the
+% possibility to specify by how much vertical space it should be
+% separated from the preceding paragraph (i.e., the caption text). The
+% attributes for font and hj setup are comparable to those for the
+% caption text itself (except that they will only apply to the
+% legend). The only addition is the key \texttt{legend-text} which is
+% allowed to take a fixed text (plus any formating and spacing for it)
+% which will be added to the front of the legend in case it is
+% provided at all (by default it is empty).
+%\begin{verbatim}
+% legend-sep =L [0pt] \caption@legend@sep ,
+% legend-text =f0 [] \caption@legend@text,
+% legend-font =f0 [\normalfont] \caption@legend@font,
+% legend-hj-setup =i {hj} [default] \caption@legend@hj@instance,
+% }
+%\end{verbatim}
+% The actual code for the template should hold few if any
+% surprises. In fact it is more or less identical to the one of the
+% first template example, except that now we have now taken out some
+% of the hardwired decisions and placed them into attributes.
+%\begin{verbatim}
+% {
+% \IfNoValueTF{#2}
+% { \cs_set_nopar:Npn \caption@start{\caption@number@format{#1}{#2}} }
+% { \cs_set_nopar:Npn \caption@start{\caption@nonumber@format{#1}} }
+% \DoParameterAssigments
+% \vskip \caption@above@skip \relax
+%\end{verbatim}
+% To properly measure the caption to determine if it fits a single
+% line we have to set it in the right font, so here as well as below
+% we have to apply |\caption@font|.
+%\begin{verbatim}
+% \sbox \@tempboxa {\caption@font \caption@start #3}
+% \ifdim \wd\@tempboxa >\hsize
+% \begingroup
+% \caption@font \caption@hj@instance
+% \caption@start #3\par
+% \endgroup
+% \else
+% \global \@minipagefalse
+% \hb@xt@\hsize{\caption@single@line@format{\box\@tempboxa}}
+% \fi
+%\end{verbatim}
+% To decide whether or not we have to set any legend we have to test
+% |#4| for being |\NoValue|. This part of the code was not present in
+% the previous example but otherwise should be straight forward.
+%\begin{verbatim}
+% \IfNoValueF{#4}
+% {
+% \vskip \caption@legend@sep \relax
+% \begingroup
+% \caption@legend@font \caption@legend@hj@instance
+% \caption@legend@text
+% #4\par
+% \endgroup
+% }
+% \vskip \caption@below@skip \relax
+% }
+%\end{verbatim}
+%
+% I wouldn't claim the the above template is good or contains
+% everything that would be desired and I'm sure that in the end we
+% will have several such template for typesetting the caption part and
+% perhaps decide on a different template type in the first place. So
+% this is only to give a glimpse of how the template interface could
+% be applied and I hope that reading it can see a) how they can apply
+% it to other areas as well as see what is wrong with the example
+% itself.
+%
+% To just note one point that i thought of being wrong after writing
+% the above paragraphs: the key \texttt{single-line-format} was
+% declared to be a function with one argument with the idea that
+% besides specifying the single line should be centered (|\hfil|) on
+% both sides, or flush left, or flush right (|\hfil| on one side) one
+% could also specify something like
+%\begin{verbatim}
+% single-line-format = \hspace{10pt}#1\hfil,
+%\end{verbatim}
+% that is a fixed indentation on the left in case where the caption is
+% a single line. However, of course one can't. Or at least it is not
+% safe to do so since our test in the code tests the width of the line
+% without taking into account such a finite fixed space and guess what
+% might happen? So in summary, flexibility needs some thought and
+% often some afterthoughts as well --- happy thinking :-)
+%
+%
+%
+% \subsection{Defining a few instances}
+%
+% So let us conclude this example with a few sample instances. We
+% start with one that repeats what current \LaTeXe{} provides in the
+% article class. It shows all keys with values. However in fact only
+% the first key is actually needed since all others are the same as
+% the default values in the template (and of course a legend is not
+% specifiable in standard \LaTeX{} coding so those settings simply do
+% not apply anyway).
+%\begin{verbatim}
+%\DeclareInstance{caption}{article}{lesssimple}
+% {
+% above-skip = 10pt,
+% below-skip = 0pt,
+% number-format = #1~#2:~,
+% nonumber-format = #1:~,
+% single-line-format = \hfil#1\hfil,
+% caption-font = \normalfont,
+% caption-hj-setup = default,
+% legend-sep = 0pt,
+% legend-text = ,
+% legend-font = \normalfont,
+% legend-hj-setup = default,
+% }
+%\end{verbatim}
+%
+% The next examples are taken from books on the shelf essentially a
+% random selection I fear. This one is from \emph{Introduction to
+% Database Design} by C.~J.~Date and it uses Helvetica for the caption
+% text with the caption flush left, with the figure and the fixed
+% string (e.g., `Fig.' in bold face) separated by a quad of space. No
+% legend either so this is not set up. The \texttt{hj} instance
+% \texttt{noindentflushleft} is supposed to produce a ragged right paragraph
+% without any indentation. It would have to be set up elsewhere
+% (instance to the template of type \texttt{hj}).
+%\begin{verbatim}
+%\DeclareInstance{caption}{DATE}{lesssimple}
+% {
+% above-skip = 10pt,
+% below-skip = 0pt,
+% number-format = \textbf{#1~#2}\quad,
+% nonumber-format = \textbf{#1}\quad,
+% single-line-format = #1\hfil,
+% caption-font = \fontfamily{phv} \normalfont,
+% caption-hj-setup = noindentflushleft,
+% }
+%\end{verbatim}
+%
+% The final example is from the book ``Methods of Book Design'' by
+% H.~Williamson which sets the caption centered if it fits a single
+% line but adjusted as a paragraph without any indentation if longer
+% than a single line. It uses old style numerals followed by a period
+% for the number (though the example isn't quite right as i guess the
+% text font used already has oldstyle numerals as default, so
+% |\oldstylenums| is in fact not necessary).
+%\begin{verbatim}
+%\DeclareInstance{caption}{WILLIAMSON}{lesssimple}
+% {
+% above-skip = 10pt,
+% below-skip = 0pt,
+% number-format = #1~\oldstylenums{#2}.~,
+% nonumber-format = #1~,
+% single-line-format = \hfil#1\hfil,
+% caption-font = \normalfont,
+% caption-hj-setup = noindentadjusted,
+% }
+%\end{verbatim}
+%
+%
+%
+% \section{Notes}
+%
+% \subsection{Note on multi-valued parameters}
+%
+%
+% The following code\footnote{docu taken from trial implementation in
+% xlists.dtx, FMi} implements for registers (ie L,l,C,c keys) and
+% for names (ie n key) a multi-selection mechanism of the following
+% form:
+% \begin{verbatim}
+% key = \MultiSelection \ListDepth {
+% \DelayEvaluation {2.5em},
+% 20pt + 34pt }
+% { \DelayEvaluation {1em} },
+% \end{verbatim}
+% where the first argument to |\MultiSelection| is a counter, the
+% second argument is a comma separated list of values denoting the
+% values for the cases 1, 2,\ldots, and the third argument contains
+% the value for all other cases.
+%
+% The values are evaluated at declaration time in case of registers
+% and therefore can contain calc expressions as well as
+% |\DelayEvaluation|.
+%
+% Due to the implementation the case list is not allowed to have a
+% trailing comma! And of course no checks are made whatsoever :-(
+%
+% A probably much nicer syntax would be something like this:
+% \begin{verbatim}
+% key = \MultiSelection {
+% selector = \ListDepth,
+% 1 = \DelayEvaluation {2.5em},
+% 2 = 20pt + 34pt,
+% else = \DelayEvaluation {1em}
+% },
+% \end{verbatim}
+% but i found that too difficult to implement right now.
+%
+% I think it should also be considered if this kind of thing should be
+% a generally available feature on all key types especially on the
+% f\meta{number} ones.
+%
+% Anyway it is what i need for lists right now and as such it is
+% sufficient.
+%
+%
+% \subsection{Notes on template restriction}
+%
+% Possible semantics:
+%
+% a: just:-) changes the defaults ie the new template has as
+% defaults those of its source as modified by the supplied
+% keyvals;
+%
+% b: similar to a: but also removes some keywords ie the new template
+% will not accept the keywods whose values are set by the suppied
+% keyvals;
+%
+% c: plan C.
+%
+%
+% Towards an implementation of b: but without a restriction on what
+% keys appear where.
+%
+%
+%
+%
+% \subsection{Open issues}
+%
+% In this section unresolved issues or ideas to think about and
+% perhaps implement are collected. There is no particular order to
+% them.
+%
+% \begin{itemize}
+% \item The order of arguments in |\UseCollection| is illogical in my
+% eyes! A collection typically modifies the behavior of several
+% types and thus should perhaps be first (as it is in the
+% |\DeclareCollectionInstance| case). Or not, or what?
+%
+% \item How should |\IfExistsInstanceTF| behave for Collection
+% instances? Do we need a special check for those or a default
+% action? Or do we need an additional test for the existence of
+% collection instances?
+%
+% \item It was suggested that the template type declaration should get
+% another argument in which (in?)formally the semantics for the
+% template types are described, e.g., data type of arguments,
+% resulting output, \ldots{} (somewhat like the description arguments
+% for functions and variables in Emacs-Lisp). The advantage being
+% that this helps employing the templates better as well as perhaps
+% guiding context sensitive editors to support the work with such
+% templates (e.g., providing help texts).
+%
+% \item The same might be of interest for the keys of individual
+% templates though here syntax support is already available to some
+% extend by the declaration of key types.
+%
+% \item There might be a need to distinguish between \TeX's dimen and
+% skip registers. Right now this is not done and both |l| and |L|
+% accepts what \LaTeX{} calls ``rubber length'' specifications.
+%
+% \item The type |b| can probably vanish. It is equivalent to
+% specifying the mutators of a |\newif| command in the brace groups,
+% e.g.
+%\begin{verbatim}
+% numbered-boolean =b [true] @heading@nums,
+% numbered-boolean =s [true] {\@heading@numstrue}
+% {\@heading@numsfalse},
+%\end{verbatim}
+%
+% \item See issue raised about syntax (and semantics) for
+% |\Multiselection|.
+%
+% \item |f0| keys should perhaps support |\UseTemplate| by replacing
+% it with its internal form. or perhaps this is a rubbish idea?
+%
+% \item Marcin Wolinski suggested to use |\EvalOnUse| instead or in
+% addition to |\DelayEvalutation|.
+%
+% \end{itemize}
+%
+% \StopEventually{}
+%
+% \section{Implementation}
+% \begin{macrocode}
+%<*package>
+\ProvidesExplPackage
+ {\filename}{\filedate}{\fileversion}{\filedescription}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\RequirePackage{expl3}
+\RequirePackage{ldcsetup,xparse}
+% \end{macrocode}
+%
+%
+% Declare a private token register for building parameter lists.
+% Having the number saves a few expandafters
+% (probably not needed in the end).
+% \begin{macrocode}
+\toks_new:N\l_TP_KV_assignments_toks
+\toks_new:N\l_TP_default_assignments_toks
+% \end{macrocode}
+%
+%
+%
+% \begin{macro}{\TP_declare_instance:Nnn}
+% \begin{macro}{\TP_declare_instance:cnn}
+% Declare a command name to be an instance of a template
+% ie with a particular setting of the parameters.\\
+% |#1| internal command name for instance to be (globally) declared\\
+% |#2| template type/template name\\
+% |#3| key value assignments for parameters of |#2|
+% \begin{macrocode}
+\cs_new_nopar:Nn \TP_declare_instance:Nnn {
+ \group_begin:
+ \TP_instdecl_generate_assignments:nn {#2}{#3}
+ \cs_gset_nopar:Npx #1 {
+ \tl_if_eq:cNTF { TP>/#2 } \c_TP_doparameterassignments_tl
+% \end{macrocode}
+% If the body of the template consists only of the token
+% |\DoParameterAssignments|, then we insert the list of parameter
+% assignments directly. Otherwise we have push them onto the stack
+% and prepare to execute the body code (which in turn will pop them
+% again when it reaches |\DoParameterAssignments| inside).
+% \begin{macrocode}
+ { \toks_use:N \l_TP_KV_assignments_toks }
+ {
+ \exp_not:N \TP_push_assignments:n
+ {\toks_use:N\l_TP_KV_assignments_toks}
+ \exp_not:c {TP>/#2}
+ }
+ }
+ \group_end:}
+\cs_generate_variant:Nn \TP_declare_instance:Nnn {cnn}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\c_TP_doparameterassignments_tl}
+% \begin{macrocode}
+\tl_set:Nn \c_TP_doparameterassignments_tl {\DoParameterAssignments}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\UseTemplate}
+% |{type}{templatename}{keyval}|
+% Directly use a template with a particular parameter setting.
+% This is also picked up if used in a nested fashion inside a parameter
+% list.\\
+% |#1| type of a template.\\
+% |#2| name of a template.\\
+% |#3| key value assignments for parameters of |#1|.
+% \begin{macrocode}
+\cs_new_nopar:Npn \UseTemplate #1#2#3{
+ \TP_instdecl_generate_assignments:nn {#1/#2}{#3}
+ \TP_push_assignments:
+ \use:c { TP>/#1/#2 }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\DoParameterAssignments}
+% Access the parameter assignment list that was once stored in
+% |\l_TP_KV_assignments_toks| and then moved onto the
+% |\g_TP_assignments_stack_toks|.
+% \begin{macrocode}
+\cs_new_nopar:Npn \DoParameterAssignments{
+ \exp_after:wN
+ \TP_pop_and_execute_assignments:nw
+ \toks_use:N \g_TP_assignments_stack_toks \q_stop
+}
+% \end{macrocode}
+%
+% \end{macro}
+%
+% \begin{macro}{\TP_pop_and_execute_assignments:nw}
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_pop_and_execute_assignments:nw#1#2\q_stop{
+ \toks_gset:Nn \g_TP_assignments_stack_toks {#2}
+ #1}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\g_TP_assignments_stack_toks}
+% \begin{macrocode}
+\toks_new:N \g_TP_assignments_stack_toks
+\toks_gset:Nn \g_TP_assignments_stack_toks {\scan_stop:}% avoid brace loss
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_push_assignments:n}
+% \begin{macro}{\TP_push_assignments:}
+% Push a list of parameter assignments onto the
+% |\g_TP_assignments_stack_toks|. As it all happens in token
+% registers |#|s need no doubling. |\TP_push_assignments:| expects
+% it to be |\l_TP_KV_assignments_toks| (needs fixing).
+% \begin{macrocode}
+\cs_new:Npn \TP_push_assignments:n#1{
+ \toks_gput_left:Nn\g_TP_assignments_stack_toks{{#1}}
+}
+\cs_new_nopar:Npn \TP_push_assignments:{
+ \toks_gset:No \g_TP_assignments_stack_toks
+ {\exp_after:wN
+ {\toks_use:N\exp_after:wN\l_TP_KV_assignments_toks\exp_after:wN}
+ \toks_use:N\g_TP_assignments_stack_toks}
+}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+%
+%
+% \begin{macro}{\DeclareTemplateType}
+% |{type}{nofarg}|
+% \begin{macrocode}
+\cs_new_nopar:Npn \DeclareTemplateType #1#2{
+ \tl_set:cn {TP@<#1>} {{}#2}}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\TP_get_csname_prefix:n}
+% |{type}| returns prefix for csnames for template type,
+% based on current collection.
+% \begin{macrocode}
+\cs_new_nopar:Nn \TP_get_csname_prefix:n {
+ <\exp_after:wN\exp_after:wN\exp_after:wN
+ \use_i:nn
+ \cs:w TP@<#1>\cs_end:>#1/
+}
+% \end{macrocode}
+%
+% \end{macro}
+%
+% \begin{macro}{\TP_get_arg_count:n}
+% |{type}| returns arg count for the template type.
+% \begin{macrocode}
+\cs_new_nopar:Nn \TP_get_arg_count:n {
+ \exp_after:wN\exp_after:wN\exp_after:wN
+ \use_ii:nn
+ \cs:w TP@<#1>\cs_end:
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\DeclareTemplate}
+% |{type}{templatename}{nofarg}{keywordspec}{code}|
+% \begin{macrocode}
+\cs_new:Npn\DeclareTemplate #1#2#3#4#5{
+ \cs_if_free:cTF{TP@<#1>}
+ {\undefinedtype\DeclareTemplateType{#1}#3}
+ {
+ \intexpr_compare:nNnF{#3}={\TP_get_arg_count:n{#1}}
+ { \BadArgCount }
+ }
+% \end{macrocode}
+% Parse the key declaration, and execute the list with a suitable
+% definition of |\KV@elt|.
+% \begin{macrocode}
+ \cs_set_eq:NN \KV_elt:nn \TP_templdecl_process_KV:nn
+ \cs_set_nopar:Npn \KV_default_elt:n##1{
+ \PackageError{template}{Missing~ =~ after~ ##1}\@ehd}
+ \cs_set_eq:NN\KV@elt\KV_elt:nn
+ \cs_set_eq:NN\KV@default@elt\KV_default_elt:n
+ \tl_set:Nn \l_TP_curr_name_tl {#1/#2}
+ \toks_clear:N\l_TP_default_assignments_toks
+% \end{macrocode}
+% At this point there should be a test for which catcode regime we are
+% in. We just test if spaces are ignored.
+% \begin{macrocode}
+ %\intexpr_compare:nNnTF{\char_value_catcode:n{`\ }}=\c_nine
+ %\KV_parse_picky_no_space_removal_no_sanitize:n
+ %\KV_parse_picky_space_removal_no_sanitize:n
+ \KV@parse{#4}
+% \end{macrocode}
+%
+% Define the defaults: the setting for |TPD>/\l_TP_curr_name_tl| is a
+% tricky since |\l_TP_default_assignments_toks| may contain |#|. We
+% have to use an |x| expansion rather than
+% |o| since that will hide those during the assignment.
+% FIX THIS (see below)!
+% \begin{macrocode}
+ \cs_set_nopar:cpx { TPD>/\l_TP_curr_name_tl }
+ {\toks_use:N\l_TP_default_assignments_toks}
+
+ \tl_clear:c {TPR>/\l_TP_curr_name_tl}
+
+ \tl_set_eq:cN {TPO>/\l_TP_curr_name_tl}\l_TP_curr_name_tl
+% \end{macrocode}
+%
+% Define the template (using |\cs_new_nopar:Npn| means that one can't
+% redefine a template easily).
+% \begin{macrocode}
+ \cs_generate_from_arg_count:cNnn {TP>/\l_TP_curr_name_tl}
+ \cs_set:Npn {#3}{#5}
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\tl_set:cx}
+% FIX this: The code above only works because in the past |\tl_set:cx| was
+% defined as follows:
+% \begin{macrocode}
+\cs_set:Npn \tl_set:cx {\exp_args:Nc \tl_set:Nx}
+% \end{macrocode}
+% i.e., expanding the second arg at the very end.
+% This is no longer the case but for the moment I revert to the old
+% definition until the template code is fixed to not rely on |\tl_set:cx|
+% expanding the second arg at the very last minute.
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_process_KV:nn}
+% The list of undefined keys and values is put in the list of the form\\
+% |\KV_elt:nn|\marg{key1}\marg{val1}%^^A
+% |\KV_elt:nn|\marg{key2}\marg{val2}\ldots\\
+% So just need to give this macro a suitable definition. We just need
+% to look at the first token of the value, to see what sort of key
+% it is, so call a helper function to split that off.
+% \begin{macrocode}
+\cs_new_nopar:Nn \TP_templdecl_process_KV:nn {%
+ \cs_set_eq:NN \TP_templdecl_add_global_or_nothing: \prg_do_nothing:
+ \bool_set_false:N\l_TP_global_assignment_bool
+ \tl_set:Nn\l_TP_currkey_tl{#1}
+ \TP_templdecl_parse_KV:N#2\q_stop}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+% \begin{macro}{\TP_templdecl_parse_KV:N}
+% Case switch on the possible key types.
+% \begin{macrocode}
+\cs_new_nopar:Nn \TP_templdecl_parse_KV:N {
+% \end{macrocode}
+% In |#1| we have key, in |#2| the first character after the equal
+% sign and in |#3| the remainder of the line. We now have to parse
+% that remainder to find out if it contains a default value (in
+% brackets) and then set up the key declaration needed to parse
+% instance declarations. The method is similar in most cases: we call
+% |\TP_parse_optional_key_default:nw| which parses for the default
+% and pass it already found key name as first argument, what to do in
+% the end as second argument, and the remainder delimited by |\q_stop|
+% so that it becomes parseable.
+%
+% Note that the code in the second argument to
+% |\TP_parse_optional_key_default:nw| normally calls on a macro with
+% one more argument than actually provided: the reason being that the
+% missing argument will be the remainder of the line (added by
+% |\TP_parse_optional_key_default:nw| after the default has be
+% removed (if present)).
+% \begin{macrocode}
+ \cs_if_free:cTF{TP_use_arg_type_#1:w}
+ {\PackageError{template}{Unknown~key~type~ (#1)~for~\l_TP_currkey_tl}\@eha}
+ {\use:c{TP_use_arg_type_#1:w}}
+% \end{macrocode}
+% The |f| and |i| keys are somewhat different since there we first
+% have to parse for an additional argument (a digit in case of |f|
+% or an template type name in case of |i|):
+% \begin{macrocode}
+% \end{macrocode}
+% One more alternative: a |+| after the equal sign signals global
+% so we change |\TP_templdecl_add_global_or_nothing:| to append a
+% |\pref_global:D| to the assignment toks and then reparse the rest.
+% \begin{macrocode}
+% \cs_set_nopar:Npn \TP_templdecl_add_global_or_nothing:
+% {\toks_put_right:Nn \l_TP_KV_assignments_toks {\pref_global:D} }
+% \TP_templdecl_parse_KV:nw{#1}#3\TP_templdecl_parse_KV:nnw
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\l_TP_global_assignment_bool}
+% For keeping track of the assignments.
+% \begin{macrocode}
+\bool_new:N \l_TP_global_assignment_bool
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_+:w}
+% The |+| does two things: Sets a boolean true to be used by the
+% types that can't simply be prefixed with |\pref_global:D| and
+% defines |\TP_templdecl_add_global_or_nothing:| to put the prefix
+% onto the list. After that we simply call the big switch
+% again.\footnote{It should probably all be changed to not rely on
+% the prefix working}.
+% \begin{macrocode}
+\cs_new_nopar:cpn{TP_use_arg_type_+:w} {
+ \bool_set_true:N\l_TP_global_assignment_bool
+ \cs_set_nopar:Npn \TP_templdecl_add_global_or_nothing:
+ {\toks_put_right:Nn \l_TP_KV_assignments_toks {\pref_global:D} }
+ \TP_templdecl_parse_KV:N
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_l:w}
+% The |l| sets a length register. We disable the prefix and insert
+% either |\gsetlength| or |\setlength| depending on whether a |+|
+% was seen or not.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_l:w {
+ \TP_parse_optional_key_default:nw
+ {
+ \cs_set_eq:NN \TP_templdecl_add_global_or_nothing: \prg_do_nothing:
+ \bool_if:NTF \l_TP_global_assignment_bool
+ {\TP_templdecl_setup_register_key:Nn\gsetlength}
+ {\TP_templdecl_setup_register_key:Nn\setlength}
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_L:w}
+% The |L| sets a fake length register.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_L:w {
+ \TP_parse_optional_key_default:nw
+ {\TP_templdecl_setup_fakeregister_key:NNn\setlength\l_tmpa_skip}
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_c:w}
+% The |c| sets a count register.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_c:w {
+ \TP_parse_optional_key_default:nw
+ {
+ \cs_set_eq:NN\TP_templdecl_add_global_or_nothing:\prg_do_nothing:
+ \bool_if:NTF \l_TP_global_assignment_bool
+ {\TP_templdecl_setup_register_key:Nn\GSetInternalCounter}
+ {\TP_templdecl_setup_register_key:Nn\SetInternalCounter}
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_C:w}
+% The |C| sets a fake count register.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_C:w {
+ \TP_parse_optional_key_default:nw
+ {\TP_templdecl_setup_fakeregister_key:NNn
+ \SetInternalCounter\l_tmpa_int}
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_n:w}
+% The |n| sets a token list variable.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_n:w {
+ \TP_parse_optional_key_default:nw
+ {\TP_templdecl_setup_n_key:N}
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_f:w}
+% \begin{macro}{\TP_templdecl_parse_f_arg:nw}
+% The |f| defines a command with between 0 and 9 arguments.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_f:w #1{
+ %\TP_templdecl_parse_f_arg:nw {#1}
+ \TP_parse_optional_key_default:nw{\TP_templdecl_setup_f_key:Nn{#1}}
+}
+% \end{macrocode}
+% Helper for |\TP_templdecl_parse_KV:nnw|.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_parse_f_arg:nw#1#2{
+% \end{macrocode}
+% The third argument of |\TP_templdecl_setup_f_key:Nn|, i.e., the
+% macro name, is the remaining data up to |\q_stop| which is picked up
+% by |\TP_parse_optional_key_default:nw|.
+% \begin{macrocode}
+ \TP_parse_optional_key_default:nw{\TP_templdecl_setup_f_key:Nn{#1}{#2}}
+}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+%
+%
+% \begin{macro}{\TP_use_arg_type_b:w}
+% \begin{macro}{\TP_templdecl_setup_b_key:nn}
+% The |b| uses access to the |\if_true:| and |\if_false:|
+% primitives. Needed?
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_b:w {
+ \TP_parse_optional_key_default:nw
+ {\TP_templdecl_setup_b_key:n}
+}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_b_key:n#1{
+ \cs_set_eq:cN { if#1 } \if_true:
+ \TP_templdecl_define_key:n
+ { \TP_templdecl_eval_b_key_value:nn {#1}{##1} }
+}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_eval_b_key_value:nn}
+% Modify so the boolean does not need to have been
+% declared with |\newif|
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_eval_b_key_value:nn#1#2{
+ \cs_if_free:cTF {if#2}
+ { \PackageError{template}{Bad~boolean~setting~#1=#2}\@eha }
+ { \tl_set_eq:cc {if_#1:}{if_#2:}
+ \toks_put_right:Nf \l_TP_KV_assignments_toks
+ { \tl_set_eq:cc {if_#1:}{if_#2:} }
+ }
+}
+% \end{macrocode}
+%
+% \end{macro}
+%
+% \begin{macro}{\TP_use_arg_type_s:w}
+% \begin{macro}{\TP_templdecl_setup_s_key:n}
+% The |s| chooses between true and false.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_s:w {
+ \TP_parse_optional_key_default:nw
+ {\TP_templdecl_setup_s_key:n}
+}
+% \end{macrocode}
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_s_key:n #1 {
+ \TP_templdecl_define_key:n
+ { \TP_templdecl_eval_s_key_value:nnn{##1}#1 }
+}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+%
+%
+%
+%
+%
+%
+%
+% \begin{macro}{\TP_use_arg_type_i:w}
+% The |i| expects an instance.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_i:w #1{
+ \TP_parse_optional_key_default:nw{\TP_templdecl_setup_i_key:nnn{#1}}
+}
+% \end{macrocode}
+%
+% declaration |hd =i{head} \fooo| \\
+% use |hd = mine|\\
+% makes |\fooo| shorthand for |\UseInstance{head}{mine}|
+%
+% also allowed: |hd = \UseTemplate{head}{...}{...}|\\
+% in case you want to use an unnamed instance of type |head|
+% in this place.
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_setup_i_key:nnn}
+% MH change: do either local or global.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_i_key:nnn#1#2{
+ \TP_templdecl_define_key:n
+ {
+ \TP_templdecl_eval_i_key_value:Nnn #2 {#1}{##1}
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_eval_i_key_value:Nnn}
+% MH change: Add extra argument for local or global.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_eval_i_key_value:Nnn #1#2#3 {
+ \tl_if_head_eq_meaning:nNTF {#3.}\UseTemplate
+ {
+ \iow_term:x{\token_to_str:N\UseTemplate\space seen}
+% \end{macrocode}
+%
+% Code below from |\TP_templdecl_setup_f_key:Nn| (should be
+% combined and cleaned up)
+% at this point one should also check if first arg of |\UseTemplate|
+% corresponds to |#2| and if not complain (not done)
+%
+% \begin{macrocode}
+ {\TP_templdecl_declare_tmp_instance:nnnn #3 }
+ \toks_put_right:No \l_TP_KV_assignments_toks
+ { \exp_after:wN \KV@toks \exp_after:wN {\g_tmpa_tl} }
+ %\TP_templdecl_add_global_or_nothing:
+ %\toks_put_right:Nn \l_TP_KV_assignments_toks
+ % { \cs_set_nopar:Npx #1{ \toks_use:N \KV@toks} }
+ \bool_if:NTF \l_TP_global_assignment_bool
+ {\toks_put_right:Nn \l_TP_KV_assignments_toks
+ {\cs_gset_nopar:Npx #1 { \toks_use:N \KV@toks}}
+ }
+ {\toks_put_right:Nn \l_TP_KV_assignments_toks
+ {\cs_set_nopar:Npx #1 { \toks_use:N \KV@toks}}
+ }
+ }
+ {
+ \TP_let_instance:Nnn#1{#2}{#3}
+% \end{macrocode}
+% We want the |\cs_set_eq:Nc| hiding in |\TP_let_instance:Nnn| to expand
+% fully to two csnames so we put a |\tex_romannumeral:D 0| (which in
+% itself expands to nothing) in front. This expands the |\cs_set_eq:Nc| fully
+% before finding out that |\cs_set_eq:NwN| is not expandable.
+% \begin{macrocode}
+ \toks_put_right:Nf \l_TP_KV_assignments_toks
+ { \TP_let_instance:Nnn#1{#2}{#3} }
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+%
+%
+%
+%
+%
+% \begin{macro}{\TP_use_arg_type_x:w}
+% \begin{macro}{\TP_templdecl_setup_x_key:nn}
+% The |x| runs internal code.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_x:w {
+ \TP_parse_optional_key_default:nw
+ {\TP_templdecl_setup_x_key:n}
+}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_x_key:n#1{
+ \TP_templdecl_define_key:n
+ { \toks_put_right:Nn\l_TP_KV_assignments_toks{#1} }
+}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+%
+%
+%
+%
+%
+% \begin{macro}{\TP_use_arg_type_g:w}
+% \begin{macro}{\TP_templdecl_setup_g_key:nn}
+% The |g| runs any code.
+% \begin{macrocode}
+\cs_new_nopar:Npn\TP_use_arg_type_g:w {
+ \TP_parse_optional_key_default:nw
+ {\TP_templdecl_setup_g_key:n}
+}
+% \end{macrocode}
+%
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_g_key:n #1 {
+ \TP_templdecl_define_key:n{#1}}
+% \end{macrocode}
+%
+% \end{macro}
+% \end{macro}
+%
+%
+%
+%
+% \begin{macro}{\TP_templdecl_define_key:n}
+% Here we define the key in the current template. Original code from
+% r522 is essentially unreadable but we keep it here until the
+% internal structure is finally sorted out.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_define_key:n#1{
+ \exp_after:wN \cs_set:Npn \cs:w
+ KV@\l_TP_curr_name_tl @\l_TP_currkey_tl
+ \exp_after:wN\cs_end:
+ \exp_after:wN##\exp_after:wN1\exp_after:wN{
+ \exp_after:wN\TP_templdecl_remove_from_default_assignments:N
+ \cs:w KV@\l_TP_curr_name_tl @\l_TP_currkey_tl
+ \exp_after:wN \cs_end:
+ \TP_templdecl_add_global_or_nothing:
+ #1
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+%
+%
+%
+%
+%
+%
+%
+% \begin{macro}{\TP_parse_optional_key_default:nw}
+% Look for default value.
+% \begin{macrocode}
+\cs_set:Npn \TP_ignore_leading_space_in_arg_ii:nn#1#2{
+ \exp_args:Nf\TP_ignore_leading_space_in_arg_ii_aux:nn
+ {\exp_not:N #2}{#1}
+}
+\cs_set:Npn \TP_ignore_leading_space_in_arg_ii_aux:nn#1#2{#2{#1}}
+
+
+\DeclareDocumentCommand\TP_parse_optional_key_default:nw{mo}{
+ \IfNoValueTF{#2}
+ {\TP_templdecl_finish_key_setup:nw{#1}}
+ {\TP_templdecl_finish_key_setup_with_default:nnw{#1}{#2}}
+}
+%\show\TP_parse_optional_key_default:nw
+%\exp_args:Nc\show{\string\TP_parse_optional_key_default:nw}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_finish_key_setup:nw}
+% After having parsed the line and not found any default value it
+% remains to actually define the key for the instance parsing by
+% executing the setup code (in |#1|) giving it |#2| (i.e., the
+% remainder of the line) as an argument.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_finish_key_setup:nw#1#2\q_stop{
+ \TP_ignore_leading_space_in_arg_ii:nn{#1}{#2}
+ %%%#1{#2}
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_finish_key_setup_with_default:nnw}
+% If there is a default the situation is more complicated since we
+% not only have to set up the key for the instance but also have to
+% add the default value to |\l_TP_default_assignments_toks| in an
+% appropriate way.
+%
+% First set up the the key itself:
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_finish_key_setup_with_default:nnw#1#2#3\q_stop{
+ \TP_ignore_leading_space_in_arg_ii:nn{#1}{#3}
+ %%% #1 {#3}
+% \end{macrocode}
+% Now we run the new key code (which is stored in |\KV@...| hopefully)
+% and give it the default found. By doing this in a group and by
+% locally emptying |\l_TP_KV_assignments_toks| we will get the
+% resulting assignment code into that register.
+%
+% (We set |\TP_templdecl_remove_from_default_assignments:N| to
+% |\use_none:n| since this is a temporary operation and we don't want
+% to change the default really.)
+% \begin{macrocode}
+ \group_begin:
+ \toks_clear:N \l_TP_KV_assignments_toks
+ \cs_set_eq:NN \TP_templdecl_remove_from_default_assignments:N \use_none:n
+ \use:c{KV@\l_TP_curr_name_tl @\l_TP_currkey_tl}{#2}
+% \end{macrocode}
+% And now for a final trick: before closing the group again and losing
+% our local changes we run |\exp_after:wN| several times to get the
+% value of |\l_TP_KV_assignments_toks| into
+% |\l_TP_default_assignments_toks| outside that group!
+% \begin{macrocode}
+ \exp_after:wN
+ \group_end:
+ \exp_after:wN
+ \toks_set:Nn
+ \exp_after:wN
+ \l_TP_default_assignments_toks
+ \exp_after:wN
+ { \cs:w KV@\l_TP_curr_name_tl @\l_TP_currkey_tl \exp_after:wN \cs_end:
+ \exp_after:wN
+ { \toks_use:N \exp_after:wN \l_TP_KV_assignments_toks
+ \exp_after:wN
+ }
+ \toks_use:N\l_TP_default_assignments_toks
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+% \begin{macro}{\c_TP_true_tl}
+% \begin{macrocode}
+\tl_new:Nn \c_TP_true_tl {true}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_eval_s_key_value:nnn}
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_eval_s_key_value:nnn#1#2#3 {
+% no error check on this yet.
+ \tl_set:Nn \l_tmpa_tl {#1}
+ \tl_if_eq:NNTF \l_tmpa_tl \c_TP_true_tl
+ { \toks_put_right:Nn \l_TP_KV_assignments_toks {#2} }
+ { \toks_put_right:Nn \l_TP_KV_assignments_toks {#3} }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_setup_register_key:Nnn}
+% This is normally called automatically by |\DeclareTemplate|.
+%
+% Command for setting a template attribute whose name
+% corresponds directly to a \TeX{} count or length register\\
+% |#1| the function to set the value eg \cs{setlength}.\\
+% |#2| key name.\\
+% |#3| the register to set.
+%
+% This command \emph{fully evaluates} the argument at declare time,
+% and assigns the value to the register. It also passes an assignment
+% of the register to the final value into the parameter list for the
+% template.
+%
+% If the value is a call to |\DelayEvaluation|, don't evaluate it now,
+% just pass the whole assignment to the template. Remember to remove
+% the |\DelayEvaluation|.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_register_key:Nn #1#2{
+ \TP_templdecl_define_key:n{
+ \tl_if_head_eq_meaning:nNTF{##1}\DelayEvaluation
+ {
+% \end{macrocode}
+% Old line commented out. Remove |\DelayEvaluation| and also remove
+% the braces surrounding its argument.
+% \begin{macrocode}
+ \toks_put_right:Nn \l_TP_KV_assignments_toks {#1#2{##1}}
+ %\toks_set:No\l_tmpa_toks{\use_ii:nn ##1}
+ %\toks_put_right:Nx \l_TP_KV_assignments_toks
+ % {\exp_not:n{#1#2}{\toks_use:N \l_tmpa_toks}}
+ }
+% \end{macrocode}
+%
+%
+% check for |\MultiSelection| creeping up and if so add something like
+%
+% \begin{verbatim}
+% \setlength\register{\ifcase\selector \or value1 \or value2
+% ... \else valueotherwise \fi}
+% \end{verbatim}
+% to |\l_TP_KV_assignments_toks|.
+%
+% \begin{macrocode}
+ {
+ \tl_if_head_eq_meaning:nNTF{##1..}\MultiSelection
+ {
+ \group_begin:
+ \TP_multiselection_add:nnnnnn #1#2##1
+ \group_end:
+% \end{macrocode}
+%
+%
+% there are probably better ways to do this (:-)
+%
+% \begin{macrocode}
+ \tl_if_in:onTF{\toks_use:N\g_TP_multiselection_toks}\DelayEvaluation
+ {
+ \toks_put_right:No\l_TP_KV_assignments_toks
+ {
+ \exp_after:wN#1\exp_after:wN#2\exp_after:wN
+ {\toks_use:N\g_TP_multiselection_toks}
+ }
+ }
+ {
+ \toks_put_right:No\l_TP_KV_assignments_toks
+ {
+ \exp_after:wN #2
+ \exp_after:wN= \toks_use:N\g_TP_multiselection_toks\scan_stop:
+ }
+ }
+% \end{macrocode}
+%
+%
+% otherwise do as before
+%
+% \begin{macrocode}
+ }
+ {
+ #1#2{##1}
+ \toks_put_right:No\l_TP_KV_assignments_toks {
+ \exp_after:wN #2 \exp_after:wN = \tex_the:D #2\scan_stop:
+ }
+ }
+ }
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+%
+%
+%
+% \begin{macro}{\DelayEvaluation}
+% \begin{macro}{\MultiSelection}
+% Since we are testing explicitly for |\DelayEvaluation| and
+% |\MultiSelection| a few places we better give them unique
+% meanings!
+% \begin{macrocode}
+\cs_new_nopar:Npn\DelayEvaluation #1{\use_none:n{\DelayEvaluation}#1}
+\cs_new_nopar:Npn\MultiSelection #1{\use_none:n{\MultiSelection}#1}
+% \end{macrocode}
+% \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_remove_from_default_assignments:N}
+% Note: the toks register is more or less a plists and should
+% perhaps be implemented as such as this would make far more
+% readable code.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_remove_from_default_assignments:N#1{
+ \cs_set_nopar:Npn \TP_tmp:w ##1#1##2##3#1##4\q_stop{
+ \l_TP_default_assignments_toks{##1##3}
+ }
+ \exp_after:wN \TP_tmp:w
+ \toks_use:N\l_TP_default_assignments_toks #1\scan_stop:#1\q_stop}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_setup_f_key:Nn}
+% Same for macro names. Again usually called automatically when
+% declaring a new template.\\
+% |#1| Determines how many arguments the function should have.\\
+% |#2| The macro to be defined.
+%
+% If the `|##1|`, the value passed as the argument of the key
+% to the macro |#2| is invoked starts with |\FunctionInstance|, then a
+% special procedure is taken. Instead of defining a macro with the
+% specified number of arguments, the paramater list of the nested
+% function instance is parsed, and |#2| is defined to be a macro
+% expanding to that instance. In this case the specified template
+% is responsible for picking up the requested number of
+% arguments. (This is \emph{not} checked.)
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_f_key:Nn#1#2{
+% \end{macrocode}
+%
+% |##1| can either be arbitrary inline code, in which case it will be
+% defined with something similar to |\newcommand[val]| so it needs to
+% use |#1| -- |#val|.
+%
+% define it locally here (why this, David???)
+% \begin{macrocode}
+ \TP_templdecl_define_key:n
+ { \TP_templdecl_define_function:NNn#1#2{##1} }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\TP_templdecl_define_function:NNn}
+% Use number of arguments to define function.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_define_function:NNn#1#2#3{
+ \cs_generate_from_arg_count:NNnn #2 \cs_set:Npn {#1}{#3}
+ \toks_put_right:Nf \l_TP_KV_assignments_toks {
+ \cs_generate_from_arg_count:NNnn #2 \cs_set:Npn {#1}{#3}
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+% \begin{macro}{\TP_templdecl_setup_n_key:N}
+% Here is the extended version that tries to deal with
+% |\MultiSelection|.
+%
+% In case of `n' keys there is no evaluation at declaration time so it
+% is not sensible to look for |\DelayEvaluation|. For this reason as
+% well as for the fact that |\TP_multiselection_add:nnnnnn| above
+% assumes that it deals
+% with registers that can be accessed via |\toks_use:N| we have to use a
+% different command to handle the |\MultiSelection| args but
+% it is essentially doing the same.
+%
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_n_key:N#1{
+ \TP_templdecl_define_key:n{
+ \tl_if_head_eq_meaning:nNTF{##1..}\MultiSelection
+ {
+ \group_begin:
+ \TP_templdecl_multiselection:nnnn ##1
+ \group_end:
+% \end{macrocode}
+% Extracting the correct item from the |\if_case:w| we are building
+% requires a bit of care. Firstly we want to expand the appropirate
+% number of times to get to the item but we also want to ensure we do
+% not have any unwanted leftover |\fi:|s or other junk which is bound
+% to cause errors later on. Therefore we start an |f| expansion (so we
+% don't have to count |\exp_after:wN|s and then stop it again when we
+% want to.
+% \begin{macrocode}
+ \toks_put_right:Nx\l_TP_KV_assignments_toks {
+ \exp_not:n{\tl_set:Nf #1} { \toks_use:N \g_TP_multiselection_toks}
+ }
+ }
+ {
+ \cs_set_nopar:Npn #1{##1} % setting it?
+ \toks_put_right:Nn \l_TP_KV_assignments_toks
+ { \tl_set:Nn #1{##1} }
+ }
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_multiselection:nnnn}
+% Start the |\if_case:w|. When the item is retrieved using an |f|
+% type expansion we better stop it at the right place once we have
+% emerged on the other side of the conditional.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_multiselection:nnnn #1#2#3#4{
+ \toks_gset:Nn \g_TP_multiselection_toks {\if_case:w #2}
+ \clist_map_inline:nn {#3}{
+ \TP_multiselection_add_or_case:n {\exp_stop_f:##1}
+ }
+ \toks_gput_right:Nn\g_TP_multiselection_toks {
+ \else: \use_i_after_fi:nw { \exp_stop_f: #4} \fi:
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+%
+%
+%
+%
+%
+% \begin{macro}{\DeclareInstance}
+% |{type}{instname}{templatename}{keyval}|
+% \begin{macrocode}
+\cs_new_nopar:Npn \DeclareInstance { \DeclareCollectionInstance{} }
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\DeclareCollectionInstance}
+% |{collection}{type}{instname}{templatename}{keyval}|
+% The fifth argument is picked up implicitly.
+% \begin{macrocode}
+\cs_new:Npn \DeclareCollectionInstance#1#2#3#4{
+ \TP_declare_instance:cnn { <#1>#2/#3 }{ #2/#4 }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\UseCollection}
+% |{type}{collection}|
+% \begin{macrocode}
+\cs_new_nopar:Npn \UseCollection#1#2{
+ \tl_set:cx { TP@<#1> }
+ { {#2} \TP_get_arg_count:n{#1} }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_let_instance:Nnn}
+% |\internalcommand{type}{instname}|
+%
+% The way this macro is used, it must result in |\cs_set_eq:NwN| |<csname1>|
+% |<csname2>| after exactly two expansions as it is used this way
+% in |\TP_templdecl_eval_i_key_value:nnn|!
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_let_instance:Nnn#1#2#3{
+ \cs_set_eq:Nc #1
+ {
+ \cs_if_free:cTF { \TP_get_csname_prefix:n{#2} #3 }
+ { <>#2/ }
+ { \TP_get_csname_prefix:n{#2} }
+ #3
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\UseInstance}
+% |{type}{instname}|
+% \begin{macrocode}
+\cs_new_nopar:Npn \UseInstance#1#2{
+ \TP_let_instance:Nnn \l_tmpa_tl {#1}{#2}
+ \tl_if_eq:NNTF \l_tmpa_tl \scan_stop:
+ \INSTANCEundefined
+ \l_tmpa_tl
+}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_declare_tmp_instance:nnnn}
+% This macro is called when we have seen a |\UseTemplate|
+% declaration as part of an |i| key value. Therefore the
+% first argument will be dropped (it contains the token
+% |\UseTemplate|) the second and third will be combined to refer to
+% the template and the fourth argument will be implictly picked up
+% by |\TP_declare_instance:Nnn|.
+% \begin{macrocode}
+\cs_new:Npn \TP_templdecl_declare_tmp_instance:nnnn#1#2#3{%
+ \TP_declare_instance:Nnn \g_tmpa_tl {#2/#3} }
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\ShowTemplate}
+% Some extension to |\ShowTemplate| so that we also get to see the
+% restrictions if any
+% \begin{macrocode}
+\cs_new_nopar:Npn \ShowTemplate#1#2{
+ \iow_term:x{*******~ Template:~ #1/#2~ *******}
+ \iow_term:x{*}
+ \iow_term:x{*~ Defaults:}
+ \iow_term:x{*}
+ \iow_term:x{\token_to_str:N\TPD>/#1/#2=
+ \cs_meaning:c{TPD>/#1/#2}}
+ \iow_term:x{*}
+ \iow_term:x{*~ Restrictions:}
+ \iow_term:x{*}
+ \iow_term:x{\token_to_str:N\TPR>/#1/#2=
+ \cs_meaning:c{TPR>/#1/#2}}
+ \iow_term:x{*}
+ \iow_term:x{*~ Body:}
+ \iow_term:x{*}
+ \cs_show:c {TP>/#1/#2}}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\ShowCollectionInstance}
+% \begin{macrocode}
+\cs_new_nopar:Npn \ShowCollectionInstance#1#2#3{
+ \iow_term:x{*******~ Instance:~ <#1>#2/#3~ *******}
+ \iow_term:x{*}
+ \cs_show:c {<#1>#2/#3}}
+\cs_new_nopar:Npn \ShowInstance{\ShowCollectionInstance{}}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_templdecl_setup_fakeregister_key:NNn}
+% |{setcomand}{privateregister}{key}{internalcode}|
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_templdecl_setup_fakeregister_key:NNn#1#2#3{
+ \TP_templdecl_define_key:n{
+ \tl_if_head_eq_meaning:nNTF{##1..}\DelayEvaluation
+ {
+% \end{macrocode}
+% In the v0.08 version of \texttt{template.dtx} a
+% |\DelayEvaluation| for a faked register would simply be equiv to
+% a |\cs_set_nopar:Npn | (code is below commented out). The negative side effect
+% of this is that something like |=L| used with |\DelayEvaluation|
+% would not allow for calc syntax since it would end up as
+% |\cs_set_nopar:Npn |\allowbreak|\foo|\allowbreak|{a+b}|. The code below changes
+% this to first assign to a scratch register (at runtime) and then
+% do an |\edef|. Could be coded differently to save space (at cost
+% of time)
+% \begin{macrocode}
+% \toks_put_right:Nn \l_TP_KV_assignments_toks {\cs_set_nopar:Npn #3{##1}}
+% \toks_put_right:Nn \l_TP_KV_assignments_toks
+% {#1#2{##1}\cs_set_nopar:Npx #3{\toks_use:N#2}}
+ \toks_set:No \l_tmpa_toks {\use_ii:nn ##1}
+ \toks_put_right:Nx \l_TP_KV_assignments_toks {
+ \exp_not:n{#1#2}{\toks_use:N \l_tmpa_toks}
+ \exp_not:n{ \cs_set_nopar:Npx #3{\toks_use:N#2} }
+
+ }
+ }
+% \end{macrocode}
+%
+%
+% Otherwise same game for fake registers except that instead of
+% passing the register to |\TP_multiselection_add:nnnnnn| we pass a
+% temp fake one and
+% doing a def instead of using |\setlength| or |\setcounter|
+%
+% and i haven't done the |\DelayEvaluation| bit for that case! as
+% i'm not sure what the best approach is for those
+% things\footnote{we might disallow it for that case in general ---
+% not a nice rule but an explainable one}
+%
+% \begin{macrocode}
+ {
+ \tl_if_head_eq_meaning:nNTF{##1..}\MultiSelection
+ {
+ \group_begin:
+ \TP_multiselection_add:nnnnnn#1#2##1
+ \group_end:
+ \toks_put_right:Nx\l_TP_KV_assignments_toks
+ {\exp_not:n{\cs_set_nopar:Npn #3} {\toks_use:N\g_TP_multiselection_toks}}
+ }
+ {
+ #1#2{##1}
+ \toks_put_right:Nx\l_TP_KV_assignments_toks
+ {\exp_not:n{\cs_set_nopar:Npn#3} {\toks_use:N#2}}
+ }
+ }
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\g_TP_multiselection_toks}
+% \begin{macrocode}
+\toks_new:N \g_TP_multiselection_toks
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\TP_multiselection_add:nnnnnn}
+% \marg{operation} \marg{register} |\MultiSelection|
+% \marg{selector} \marg{case-list} \marg{else-case}
+%
+% This command builds up the |\if_case:w| code from the three
+% arguments of |\MultiSelection| and stores it in
+% |\g_TP_multiselection_toks|. This code is supposed to be run in a
+% group so a) we don't have to initialise |\g_TP_multiselection_toks|
+% and b) all changes to the used registers not affecting the
+% outside.
+%
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_multiselection_add:nnnnnn #1#2#3#4#5#6{
+ \toks_gset:Nn \g_TP_multiselection_toks {\if_case:w #4}
+ \clist_map_inline:nn {#5}{
+ \tl_if_head_eq_meaning:nNTF{##1..}\DelayEvaluation
+ {
+ \TP_multiselection_add_or_case:n {##1}
+ }
+ {
+ #1#2{##1}
+ \TP_multiselection_add_or_case:o { \toks_use:N #2 }
+ }
+ }
+ \toks_gput_right:Nn \g_TP_multiselection_toks {
+ \else: \use_i_after_fi:nw{#6}\fi:
+ }
+}
+% \end{macrocode}
+%
+% \end{macro}
+%
+% \begin{macro}{\TP_multiselection_add_or_case:o}
+% No need to worry about where |\or:| is allowed to be added since
+% all loops in \LaTeX3 process the item outside conditionals.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_multiselection_add_or_case:n #1 {
+ \toks_gput_right:Nn \g_TP_multiselection_toks {
+ \or: \use_i_after_orelse:nw{#1}
+ }
+}
+\cs_generate_variant:Nn \TP_multiselection_add_or_case:n {o}
+% \end{macrocode}
+% \end{macro}
+%
+% Since i like to set things like |item-label-text| using this
+% mechanism i need to handle the `n' key specially.
+%
+% Actually i could have probably extended
+% |\TP_templdecl_setup_f_key:nnN| thus making
+% this generally available to all f\meta{number} keys but was too lazy
+% (or too stupid) to get it right first time so settled for the simple
+% solution.
+%
+% So |\TP_templdecl_parse_KV:nnw| now calls
+% |\TP_templdecl_setup_n_key:nN| for the `n' key. looks like
+% this thus be fixed some time soon
+%
+%
+%
+%
+%
+%
+%
+% \begin{macro}{\IfExistsInstanceTF}
+% tests that there is a \emph{default} definition
+% taken from xinitials.dtx:
+% \begin{macrocode}
+\cs_new_nopar:Npn \IfExistsInstanceTF#1#2{
+ \cs_if_exist:cTF{<>#1/#2}
+}
+% \end{macrocode}
+%
+% FMi: what happens if we are in collection FOO and there exists an
+% instance I for type T within this collection but there doesn't exist
+% an instance in the empty collection?
+%
+% What would happen if \ldots\ --- not clear to me what the sematics
+% really should be. The code below is not better only different( and
+% slower).\footnote{fix semantics}
+% \begin{macrocode}
+\cs_set_nopar:Npn \IfExistsInstanceTF#1#2{
+ \TP_let_instance:Nnn \l_tmpa_tl {#1}{#2}
+% next is not \tl_if_eq:NNTF but ...FT so done manually
+ \if_meaning:w\l_tmpa_tl\scan_stop:
+ \exp_after:wN\use_ii:nn
+ \else:
+ \exp_after:wN\use_i:nn
+ \fi:}
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\DeclareRestrictedTemplate}
+% Setting it up:
+%
+%| \DeclareRestrictedTemplate|\\
+% |{T-type} {new-T-name} {source-T-name} {keyvals}|
+%
+% This uses the same code as {T-type} {source-T-name} but adds
+% settings from {keyvals}
+% \begin{macrocode}
+\cs_new_nopar:Npn \DeclareRestrictedTemplate#1#2#3#4{
+ % CCC do we need a group here??
+ \tl_set_eq:cc { TPD>/#1/#2 } { TPD>/#1/#3 }
+ \tl_set_eq:cc { TP>/#1/#2 } { TP>/#1/#3 }
+ \toks_set:Nv \l_TP_KV_assignments_toks { TPR>/ #1 / #3 }
+% adds stuff to \l_TP_KV_assignments_toks
+ \setkeys {\cs:w TPO>/#1/#3\cs_end:}{#4}
+
+ \tl_set:cx { TPR>/#1/#2 }
+ { \toks_use:N \l_TP_KV_assignments_toks }
+ \cs_if_free:cTF { TPO>/#1/#3 }
+ { \tl_set:cn {TPO>/#1/#2}{#1/#3} }
+ { \tl_set_eq:cc {TPO>/#1/#2}{TPO>/#1/#3} }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% Internals:
+%
+% \begin{macro}{\TP_instdecl_generate_assignments:nn}
+% These could probably be inlined, even when they do something!
+%
+% Assumption: setkeys fully expands its first argument.
+%
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_instdecl_generate_assignments:nn#1#2 {
+ % Returns to \l_TP_KV_assignments_toks
+ % the restrictions
+ % stored in the TP-structure (at present
+ % in YAM) of the template #1
+ \exp_args:NNo \toks_set:No \l_TP_default_assignments_toks
+ {\cs:w TPD>/#1\cs_end:\scan_stop:\scan_stop:}
+ \toks_set:Nv \l_TP_KV_assignments_toks { TPR>/ #1 }
+ \setkeys { \cs:w TPO>/#1 \cs_end: }
+ { #2 } % adds stuff to \l_TP_KV_assignments_toks
+
+% prepends stuff to \l_TP_KV_assignments_toks :
+ \exp_after:wN\TP_instdecl_add_default_recurse:nn
+ \toks_use:N\l_TP_default_assignments_toks
+
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+% \begin{macro}{\TP_instdecl_add_default_recurse:nn}
+% [ 2001/06/10 Think about doing this properly with explicit plists! --- but
+% this means that one has to think about whether or not plists should be
+% implemented as token registers and not as tl vars as they are now. ]
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_instdecl_add_default_recurse:nn#1#2{
+ \token_if_eq_meaning:NNF #1\scan_stop:
+ {
+ \l_tmpa_toks{#2}
+ \tl_set:Nx \l_tmpa_tl {
+ {\toks_use:N \l_tmpa_toks \toks_use:N \l_TP_KV_assignments_toks}
+ }
+ \l_TP_KV_assignments_toks \l_tmpa_tl
+ \TP_instdecl_add_default_recurse:nn
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+% |TPD>/type/name| stores the default parameter assignments.
+%
+% |TPR>/type/name| stores the parameter assignments that have been
+% made for a restricted template otherwise it is undefined (or |\scan_stop:|).
+%
+%
+% |TPO>/type/name| stores the full name (i.e. as |type/name|)
+% of the template a restricted
+% template is coming from originally.
+%
+%
+%
+%
+% \begin{macro}{\TP_split_finite_skip_value:nnNN}
+% This macro is for use in error checking template values like
+% "text-float-sep" that can't contain infinite glue and needs the
+% shrink and/or stretch components. First argument is the skip
+% register (which is likely to be user input), second is a template
+% key name, and the last two are the \meta{dimen} registers that
+% stores the stretch and shrink components. Assignments are global.
+% \begin{macrocode}
+\cs_new_nopar:Npn \TP_split_finite_skip_value:nnNN #1#2{
+ \skip_split_finite_else_action:nnNN {#1} {
+ \PackageError{template}{Value~ for~ key~ #2~ contains~ `fil(ll)'}
+ {Only~ finite~ minus~ or~ plus~ parts~ are~ allowed~ for~ this~ key.}
+ }
+}
+% \end{macrocode}
+% \end{macro}
+%
+%
+%
+%
+% \begin{macrocode}
+%</package>
+% \end{macrocode}
+%
+% \Finale
+%
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/tprestrict-test.tex b/Master/texmf-dist/source/latex/xpackages/xbase/tprestrict-test.tex
new file mode 100644
index 00000000000..a787694abff
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/tprestrict-test.tex
@@ -0,0 +1,80 @@
+% \iffalse
+%% (C) Copyright 2000-2004 LaTeX3 Project
+%%
+%% It may be distributed and/or modified under the conditions of the
+%% LaTeX Project Public License (LPPL), either version 1.3a 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% $Id: tprestrict-test.tex 251 2004-11-11 19:01:16Z mittelba $
+%%
+% \fi
+%
+
+\makeatletter
+\RequirePackage{template}
+\IgnoreWhiteSpace
+
+\newcount\ca
+\newdimen\da
+
+
+\DeclareTemplateType{type}{0}
+
+\DeclareTemplate{type}{Ta}{0}{
+ one =l [2in] \da,
+ two =c [5] \ca}
+ {\DoParameterAssignments\typeout{\da=\the\da,\@spaces \ca=\the\ca}}
+
+\ShowTemplate{type}{Ta}
+
+\typeout{1^^J==}
+\UseTemplate{type}{Ta}{}
+
+\typeout{2^^J==}
+\UseTemplate{type}{Ta}{one=44pt, two=7}
+
+
+\DeclareRestrictedTemplate{type}{Tb}{Ta}{one=33pt}
+
+\ShowTemplate{type}{Tb}
+
+\typeout{RESTRICT^^J3^^J==}
+
+\DeclareInstance{type}{foo}{Tb}{two=9}
+
+\ShowInstance{type}{foo}
+
+\UseInstance{type}{foo}
+
+\typeout{4^^J==}
+\UseTemplate{type}{Tb}{two=7}
+
+\stop
+
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/xbase.ins b/Master/texmf-dist/source/latex/xpackages/xbase/xbase.ins
new file mode 100644
index 00000000000..742a1aa8dc3
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/xbase.ins
@@ -0,0 +1,73 @@
+% \iffalse
+%%
+%% This file will generate fast loadable files and documentation
+%% driver files from the dtx files in this package when run through
+%% LaTeX or TeX.
+%%
+%% (C) Copyright 2000-2005 LaTeX3 Project
+%%
+%% It may be distributed and/or modified under the conditions of the
+%% LaTeX Project Public License (LPPL), either version 1.3a 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% $Id: xbase.ins 302 2005-03-01 22:49:14Z morten $
+%%
+% \fi
+%
+
+\input docstrip
+\keepsilent
+\askforoverwritefalse
+
+\preamble
+
+(C) Copyright The LaTeX3 Project and any individual authors
+listed elsewhere in this file.
+
+This is a generated file.
+
+This file was generated from file(s) of the xbase bundle.
+---------------------------------------------------------
+
+This file may only be distributed together with a copy of this bundle.
+You may however distribute the bundle without such generated files.
+
+======================================================================
+
+\endpreamble
+
+
+\generate{%
+ \file{ldcsetup.sty}{\from{ldcsetup.dtx}{package}}
+ \file{template.sty}{\from{template.dtx}{package,trace}}
+ \file{xparse.sty}{\from{xparse.dtx}{package}}
+}
+
+\endbatchfile
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/xparse-test.tex b/Master/texmf-dist/source/latex/xpackages/xbase/xparse-test.tex
new file mode 100644
index 00000000000..9e681adf520
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/xparse-test.tex
@@ -0,0 +1,296 @@
+% \iffalse
+%% (C) Copyright 2000-2009 LaTeX3 Project
+%%
+%% It may be distributed and/or modified under the conditions of the
+%% LaTeX Project Public License (LPPL), either version 1.3a 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% $Id: xparse-test.tex 1487 2009-08-22 15:55:24Z joseph $
+%%
+% \fi
+%
+
+\documentclass{minimal}
+
+\usepackage{xparse,l3box}
+
+
+\typeout{Testing the complicated makebox setup}
+\typeout{*****************************}
+\typeout{* look at dvi output for this part}
+\typeout{*****************************}
+
+\ExplSyntaxOn
+\makeatletter
+% Let's just take the error messages for a ride:
+\cs_set_nopar:Npn \makebox{}
+% Here should be an error because it is defined
+\NewDocumentCommand \makebox {m}{Gobbledygook}
+\cs_gundefine:N \makebox
+% And now one for being undefined
+\RenewDocumentCommand \makebox {m}{More~gobbledygook}
+\cs_set_eq:NN \makebox \scan_stop:
+% Another one for being undefined
+\RenewDocumentCommand \makebox {m}{Even~more~gobbledygook}
+% Now it should work
+\DeclareDocumentCommand \makebox
+ { >{\xparse_process_comma_split:n}d() o O{c} m}
+ {\IfNoValueTF{#1}
+ { \ltx@maketextbox{#2}{#3}{#4}\mbox }
+ { \ltx@makepicbox #1 {#2}{#4}\@firstofone }
+ }
+
+\DeclareDocumentCommand \framebox
+ { >{\xparse_process_comma_split:n} d() o O{c} m}
+ {
+ \IfNoValueTF{#1}
+ { \ltx@maketextbox{#2}{#3}{#4}\fbox }
+ { \ltx@makepicbox #1 {#2}{#4}\frame }
+ }
+
+\def\ltx@maketextbox#1#2#3#4{
+ \IfNoValueTF{#1}
+ {#4{#3}}
+ {
+ \leavevmode
+ \@begin@tempboxa\hbox{#3}
+ \setlength\@tempdima{#1}
+ \if_meaning:w #4\fbox
+ \setbox\@tempboxa\hb@xt@\@tempdima{
+ \kern\fboxsep
+ \use:c{bm@#2}
+ \kern\fboxsep
+ }
+ \@frameb@x{\kern-\fboxrule}
+ \else:
+ \hb@xt@\@tempdima{\use:c{bm@#2}}
+ \fi:
+ \@end@tempboxa
+ }
+}
+
+\def\ltx@makepicbox#1#2#3#4#5{
+ #5
+ {
+ \vbox to#2\unitlength {
+ \cs_set_eq:NN \mb@b\vss \cs_set_eq:NN \mb@l\hss
+ \cs_set_eq:NN \mb@r\hss \cs_set_eq:NN \mb@t\vss
+ \IfNoValueF{#3}{
+ \tl_map_variable:nNn {#3}\l_tmpa_tl {
+ \if:w s\l_tmpa_tl
+ \cs_set_eq:NN \mb@l \scan_stop:
+ \cs_set_eq:NN \mb@r \scan_stop:
+ \else:
+ \cs_set_eq:cN {mb@\l_tmpa_tl}\scan_stop:
+ \fi:
+ }
+ }
+ \mb@t
+ \hb@xt@ #1\unitlength{\mb@l #4\mb@r}
+ \mb@b
+ \kern\z@
+ }
+ }
+}
+
+\makeatother
+\ExplSyntaxOff
+
+\begin{document}
+
+
+\thicklines
+
+\makebox{A}
+\makebox(1,2){B}
+\makebox(0,0)[lt]{C}
+\makebox[20pt]{D}
+\makebox[30pt][r]{E}
+
+\vspace{1cm}
+
+
+\framebox{A}
+\framebox(1,2){B}
+\framebox(0,0)[lt]{C}
+\framebox[20pt]{D}
+\framebox[30pt][r]{E}
+
+
+\typeout{Testing optional coordinates}
+
+\DeclareDocumentCommand \foo { mmo }
+{ \typeout{1:#1}
+ \typeout{2:#2}
+}
+
+\show\foo
+
+\ExplSyntaxOn
+\DeclareDocumentCommand \foo
+ { m >{\xparse_process_comma_split:n} D(){0,0} m }
+{ \typeout{1:#1}
+ \typeout{2:#2}
+ \typeout{3:#3}
+}
+\ExplSyntaxOff
+
+\show\foo
+
+\foo A(1,2)B
+
+\foo A B
+
+\typeout{Testing mandatory coordinates (gives error on second examples)}
+
+\ExplSyntaxOn
+\DeclareDocumentCommand \foo { m >{\xparse_process_comma_split:n} d() m }
+{ \IfNoValueTF {#2} {
+ \ERROR
+ }{
+ \typeout{1:#1}
+ \typeout{2:#2}
+ \typeout{3:#3}
+ }
+}
+\ExplSyntaxOff
+
+\show\foo
+
+\foo A(1,2)B
+
+\foo A B
+
+\typeout{Testing normal optional arguments}
+
+
+\DeclareDocumentCommand \foo { mmmm o mm o }
+{ \typeout{1:#1}
+ \typeout{2:#2}
+ \typeout{3:#3}
+ \typeout{4:#4}
+ \typeout{5:#5}
+ \typeout{6:#6}
+ \typeout{7:#7}
+ \typeout{8:#8}
+}
+
+\foo 1234 [5]67[8]
+\foo 1234 [5]67 [8] % 8 should not be picked up here
+\foo 123467
+
+\show\foo
+\expandafter\show\csname\string\foo\endcsname
+
+
+\typeout{Testing optional arguments with default}
+
+\DeclareDocumentCommand \baz { O{?}mmm o mm m }
+{ \typeout{1:#1}
+ \typeout{2:#2}
+ \typeout{3:#3}
+ \typeout{4:#4}
+ \typeout{5:#5}
+ \typeout{6:#6}
+ \typeout{7:#7}
+ \typeout{8:#8}
+}
+
+\show\baz
+\expandafter\show\csname\string\baz\endcsname
+
+\baz [1]234[5]678
+\baz 234678
+
+%\tracingall\tracingassigns=1
+\DeclareDocumentCommand \bar { mmmm mmmm m}
+{ \typeout{1:#1}
+ \typeout{2:#2}
+ \typeout{3:#3}
+ \typeout{4:#4}
+ \typeout{5:#5}
+ \typeout{6:#6}
+ \typeout{7:#7}
+ \typeout{8:#8}
+ \typeout{9:#9}
+}
+
+\show\bar
+\expandafter\show\csname\string\bar\endcsname
+
+\bar 123456789
+
+\DeclareDocumentCommand\chapter{soom}
+{\typeout{a{#1}^^Jb{#2}^^Jc{#3}^^Jd{#4}^^Je}}
+
+\show\chapter
+\expandafter\show\csname\string\chapter\endcsname
+
+\typeout{1:}
+\chapter*[xxx][yyy]{zzz}
+
+\typeout{2:}
+\chapter[xxx][yyy]{zzz}
+
+\typeout{3:}
+\chapter*[xxx]{zzz}
+
+\typeout{4:}
+\typeout{\chapter*[xxx][yyy]{zzz}}
+
+
+
+
+\DeclareDocumentCommand\chapter{soom}
+{\typeout{a{#1}^^Jb{#2}^^Jc{#3}^^Jd{#4}^^Je}}
+
+\DeclareDocumentEnvironment{hello}{ooo}
+ {\typeout{B1(#1)^^JB2(#2)^^JB3(#3)^^J}}
+ {\typeout{E1(#1)^^JE2(#2)^^JE3(#3)^^J}}
+
+
+\show\hello
+\expandafter\show\csname\string\hello\endcsname
+
+\show\endhello
+\expandafter\show\csname end\string\\hello\endcsname
+
+\begin{hello}[abc][aabbcc]
+\typeout{body}
+\typeout{5:}
+\chapter[xxx][yyy]{zzz}
+\end{hello}
+
+\begin{hello}[1]
+\typeout{outer body}
+\hello[2]\typeout{inner body}\endhello
+\end{hello}
+
+\stop
diff --git a/Master/texmf-dist/source/latex/xpackages/xbase/xparse.dtx b/Master/texmf-dist/source/latex/xpackages/xbase/xparse.dtx
new file mode 100644
index 00000000000..c227c4612f3
--- /dev/null
+++ b/Master/texmf-dist/source/latex/xpackages/xbase/xparse.dtx
@@ -0,0 +1,2443 @@
+% \iffalse
+%% File: xparse.dtx (C) Copyright 1999 Frank Mittelbach, Chris Rowley,
+%% David Carlisle
+%% (C) Copyright 2004-2008 Frank Mittelbach,
+%% LaTeX3 Project
+%% (C) Copyright 2009 LaTeX3 Project
+%%
+%% It 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 file is part of the ``xbase bundle'' (The Work in LPPL)
+%% and all files in that bundle must be distributed together.
+%%
+%% The released version of this bundle is available from CTAN.
+%%
+%% -----------------------------------------------------------------------
+%%
+%% The development version of the bundle can be found at
+%%
+%% http://www.latex-project.org/svnroot/experimental/trunk/
+%%
+%% for those people who are interested.
+%%
+%%%%%%%%%%%
+%% NOTE: %%
+%%%%%%%%%%%
+%%
+%% Snapshots taken from the repository represent work in progress and may
+%% not work or may contain conflicting material! We therefore ask
+%% people _not_ to put them into distributions, archives, etc. without
+%% prior consultation with the LaTeX Project Team.
+%%
+%% -----------------------------------------------------------------------
+%%
+%
+%<*driver|package>
+\RequirePackage{l3names}
+%</driver|package>
+%\fi
+\GetIdInfo$Id: xparse.dtx 1497 2009-08-31 19:17:53Z joseph $
+ {Generic document command parser}
+%\iffalse
+%<*driver>
+%\fi
+\ProvidesFile{\filename.\filenameext}
+ [\filedate\space v\fileversion\space\filedescription]
+%\iffalse
+\documentclass{l3doc}
+\begin{document}
+ \DocInput{xparse.dtx}
+\end{document}
+%</driver>
+% \fi
+%
+% \title{The \textsf{xparse} package\thanks{This file
+% has version number \fileversion, last
+% revised \filedate.}\\
+% Generic document command parser}
+% \author{\Team}
+% \date{\filedate}
+% \maketitle
+%
+%\begin{documentation}
+%
+%\section{Creating document commands}
+%
+% The \pkg{xparse} package provides a high-level interface for
+% producing document-level commands. In that way, it is intended as
+% a replacement for the \LaTeXe\ \cs{newcommand} macro. However,
+% \pkg{xparse} works so that the interface to a function (optional
+% arguments, stars and mandatory arguments, for example) is separate
+% from the internal implementation. \pkg{xparse} provides a normalised
+% input for the internal form of a function, independent of the
+% document-level argument arrangement.
+%
+% At present, the functions in \pkg{xparse} which are regarded as
+% `stable' are:
+%\begin{itemize}
+% \item \cs{DeclareDocumentCommand}
+% \item \cs{NewDocumentCommand}
+% \item \cs{RenewDocumentCommand}
+% \item \cs{ProvideDocumentCommand}
+% \item \cs{DeclareDocumentEnvironment}
+% \item \cs{NewDocumentEnvironment}
+% \item \cs{RenewDocumentEnvironment}
+% \item \cs{ProvideDocumentEnvironment}
+% \item \cs{IfNoValue(TF)} (the need for \cs{IfValue(TF)} is currently
+% an item of active discussion)
+% \item \cs{IfBoolean(TF)}
+%\end{itemize}
+% with the other functions currently regarded as `experimental'. Please
+% try all of the commands provided here, but be aware that the
+% experimental ones may change or disappear.
+%
+%\subsection{Specifying arguments}
+%
+% Before introducing the functions used to create document commands,
+% the method for specifiying arguments with \pkg{xparse} will be
+% illustrated. In order to allow each argument to be defined
+% independently, \pkg{xparse} does not simply need to know the
+% number of arguments for a function, but also the nature of each
+% one. This is done by constructing an \emph{argument specification},
+% which defines the number of arguments, the type of each argument
+% and any additional information needed for \pkg{xparse} to read the
+% user input and properly pass it thorugh to internal functions.
+%
+% The basic form of the argument specifier is a list of letters, where
+% each letter defines a type of argument. As will be described below,
+% some of the types need additional information, such as default values.
+% The argument types can be divided into two, those which define
+% arguments that are mandatory (potentially raising an error if not
+% found) and those which define optional arguments. The mandatory types
+% are:
+%\begin{itemize}[font=\ttfamily]
+% \item[m] A standard mandatory argument, which can either be a single
+% token alone or multiple tokens surrounded by curly braces.
+% Regardless of the input, the argument will be passed to the
+% internal code surrounded by a brace pair. This is the \pkg{xparse}
+% type specifier for a normal \TeX\ argument.
+% \item[l] An argument which reads everything up to the first
+% open group token: in standard \LaTeX\ this is a left brace.
+% \item[u] Reads an argument `until' \meta{tokens} are encountered,
+% where the desired \meta{tokens} are given as an argument to the
+% specifier: \texttt{u}\marg{tokens}.
+%\end{itemize}
+% The types which define optional arguments are:
+%\begin{itemize}[font=\ttfamily]
+% \item[o] A standard \LaTeX\ optional argument, surrounded with square
+% brackets, which will supply
+% the special \cs{NoValue} token if not given (as described later).
+% \item[d] An optional argument which is delimited by \meta{token1}
+% and \meta{token2}, which are given as arguments:
+% \texttt{d}\meta{token1}\meta{token2}. As with \texttt{o}, if no
+% value is given the special token \cs{NoValue} is returned.
+% \item[O] As for \texttt{o}, but returns \meta{default} if no
+% value is given. Should be given as \texttt{O}\marg{default}.
+% \item[D] As for \texttt{d}, but returns \meta{default} if no
+% value is given: \texttt{D}\meta{token1}\meta{token2}\marg{default}.
+% Internally, the \texttt{o}, \texttt{d} and \texttt{O} types are
+% shortcuts to an appropriated-constructed \texttt{D} type argument.
+% \item[s] An optional star, which will result in a value
+% \cs{BooleanTrue} if a star is present and \cs{BooleanFalse}
+% otherwise (as described later).
+% \item[t] An optional \meta{token}, which will result in a value
+% \cs{BooleanTrue} if \meta{token} is present and \cs{BooleanFalse}
+% otherwise. Given as \texttt{t}\meta{token}.
+% \item[g] An optional argument given inside a pair of \TeX\ group
+% tokens (in standard \LaTeX, |{| \ldots |}|).
+%\end{itemize}
+%
+% Using these specifiers, it is possible to create complex input syntax
+% very easily. For example, given the argument definition
+% `|s o o m O{default}|', the input `|*[Foo]{Bar}|' would be parsed as:
+%\begin{itemize}[nolistsep]
+% \item |#1| = |\BooleanTrue|
+% \item |#2| = |{Foo}|
+% \item |#3| = |\NoValue|
+% \item |#4| = |{Bar}|
+% \item |#5| = |{default}|
+%\end{itemize}
+% whereas `|[One][Two]{}[three]|' would be parsed as:
+%\begin{itemize}[nolistsep]
+% \item |#1| = |\BooleanFalse|
+% \item |#2| = |{One}|
+% \item |#3| = |{Two}|
+% \item |#4| = |{}|
+% \item |#5| = |{Three}|
+%\end{itemize}
+% Note that after parsing the input there will be always exactly the
+% same number of brace groups or tokens as the number of letters in the
+% argument specifier.
+%
+% Two more tokens have a special meaning when creating an argument
+% specifier. First, \texttt{+} is used to make an argument long (to
+% accept paragraph tokens). In contrast to \LaTeXe's \cs{newcommand},
+% this applies on an argument-by-argument basis. So modifying the
+% example to `|s o o +m O{default}|' means that the mandatory argument
+% is now \cs{long}, whereas the optional arguments are not.
+%
+% Secondly, the token \texttt{>} is used to declare so-called
+% `argument processors', which can be used to modify the contents of an
+% argument before it is passed to the macro definition. The use of
+% argument processors is a somewhat advanced topic, (or at least a less
+% commonly used feature) and is covered in Section~\ref{sec:processors}.
+%
+%\subsection{Declaring commands and environments}
+%
+% With the concept of an argument specifier defined, it is now
+% possible to describe the methods available for creating both
+% functions and environments using \pkg{xparse}.
+%
+% The interface-building commands are the preferred method for
+% creating document-level functions in \LaTeX3. All of the functions
+% generated in this way are naturally robust (using the \eTeX\
+% \cs{protected} mechanism).
+%
+%\begin{function}{
+% \DeclareDocumentCommand|
+% \NewDocumentCommand|
+% \RenewDocumentCommand|
+% \ProvideDocumentCommand
+%}
+% \begin{syntax}
+% "\DeclareDocumentCommand" <function> \Arg{arg spec} \Arg{code}
+% \end{syntax}
+% This family of commands are used to create a document-level
+% <function>. The argument specification for the function is
+% given by <arg spec>, and the function will execute <code>.
+%
+% As an example:
+% \begin{verbatim}
+% \DeclareDocumentCommand \chapter { s o m } {
+% \IfBooleanTF {#1} {
+% \typesetnormalchapter {#2} {#3}
+% }{
+% \typesetstarchapter {#3}
+% }
+% }
+% \end{verbatim}
+% would be a way to define a \cs{chapter} command which would
+% essentially behave like the current \LaTeXe\ command (except that it
+% would accept an optional argument even when a \texttt{*} was parsed).
+% The \cs{typesetnormalchapter} could test its first argument for being
+% \cs{NoValue} to see if an optional argument was present.
+%
+% The difference between the \cs{Declare\ldots}, \cs{New\ldots}
+% \cs{Renew\ldots} and \cs{Provide\ldots} versions is the behaviour
+% if <function> is already defined.
+% \begin{itemize}
+% \item \cs{DeclareDocumentCommand} will always create the new
+% definition, irrespective of any existing <function> with the
+% same name.
+% \item \cs{NewDocumentCommand} will issue an error if <function>
+% has already been defined.
+% \item \cs{RenewDocumentCommand} will issue an error if <function>
+% has not previously been defined.
+% \item \cs{ProvideDocumentCommand} creates a new definition for
+% <function> only if one has not already been given.
+% \end{itemize}
+%
+% \begin{texnote}
+% Unlike \LaTeXe's \cs{newcommand} and relatives, the
+% \cs{DeclareDocumentCommand} function do not prevent creation of
+% functions with names starting \cs{end\ldots}.
+% \end{texnote}
+%\end{function}
+%
+%\begin{function}{%
+% \DeclareDocumentEnvironment|
+% \NewDocumentEnvironment|
+% \RenewDocumentEnvironment|
+% \ProvideDocumentEnvironment
+%}
+% \begin{syntax}
+% "\DeclareDocumentEnvironment" \Arg{environment} \Arg{arg spec}
+% ~~~~\Arg{start code} \Arg{end code}
+% \end{syntax}
+% These commands work in the same way as \cs{DeclareDocumentCommand},
+% etc., but create environments (\cs{begin}|{|<function>|}| \ldots
+% \cs{end}|{|<function>|}|). Both the <start code> and <end code>
+% may access the arguments as defined by <arg spec>.
+%
+% \begin{texnote}
+% When loaded as part of a \LaTeX3 format, these, these commands do
+% not create a pair of macros \cs{<environment>} and
+% \cs{end<environment>}. Thus \LaTeX3 environments have to be
+% accessed using the \cs{begin} \ldots \cs{end} mechanism. When
+% \pkg{xparse} is loaded as a \LaTeXe\ package, \cs{<environment>}
+% and \cs{end<environment>} are defined, as this is necessary to
+% allow the new environment to work!
+% \end{texnote}
+%\end{function}
+%
+%\subsection{Testing special values}
+%
+% Optional arguments created using \pkg{xparse} make use of dedicated
+% variables to return information about the nature of the argument
+% received.
+%
+%\begin{variable}{\NoValue}
+% \cs{NoValue} is a special marker returned by \pkg{xparse} if no
+% value is given for an optional argument. If typeset (which should
+% not happen), it will print the value \texttt{-NoValue-}.
+%\end{variable}
+%
+%\begin{function}{\IfNoValue / (TF) (EXP)}
+% \begin{syntax}
+% "\IfNoValueTF" \Arg{argument} \Arg{true code} \Arg{false code}
+% \end{syntax}
+% The \cs{IfNoValue} tests are used to check if <argument> (|#1|,
+% |#2|, etc.) is the special \cs{NoValue} token. For example
+% \begin{verbatim}
+% \DeclareDocumentCommand \foo { o m } {
+% \IfNoValueTF {#1} {
+% \DoSomethingJustWithMandatoryArgument {#2}
+% }{
+% \DoSomethingBothArguments {#1} {#2}
+% }
+% }
+% \end{verbatim}
+% will use a different internal function if the optional argument
+% is given than if it is not present.
+%
+% As the \cs{IfNoValue} tests are expandable, it is possible to test
+% these values later, for example at the point of typesetting or in
+% an expansion context.
+%\end{function}
+%
+%\begin{function}{\IfValue / (TF) (EXP)}
+% \begin{syntax}
+% "\IfValueTF" \Arg{argument} \Arg{true code} \Arg{false code}
+% \end{syntax}
+% The reverse form of the \cs{IfNoValue(TF)} tests are also available
+% as \cs{IfValue(TF)}. The context will determine which logical
+% form makes the most sense for a given code senario.
+%\end{function}
+%
+%\begin{variable}{
+% \BooleanFalse|
+% \BooleanTrue
+%}
+% The \texttt{true} and \texttt{false} flags set when searching for
+% an optional token (using \texttt{s} or \texttt{t}<token>) have
+% names which are accessible outside of code blocks.
+%\end{variable}
+%
+%\begin{function}{\IfBoolean / (TF) (EXP)}
+% \begin{syntax}
+% "\IfBooleanTF" <argument> \Arg{true code} \Arg{false code}
+% \end{syntax}
+% Used to test if <argument> (|#1|, |#2|, etc.) is \cs{BooleanTrue}
+% or \cs{BooleanFalse}. For example
+% \begin{verbatim}
+% \DeclareDocumentCommand \foo { s m } {
+% \IfBooleanTF #1 {
+% \DoSomethingWithStar {#2}
+% }{
+% \DoSomethingWithoutStar {#2}
+% }
+% }
+% \end{verbatim}
+% checks for a star as the first argument, then chooses the action to
+% take based on this information.
+%\end{function}
+%
+%\subsection{Argument processors}
+%\label{sec:processors}
+%
+% \pkg{xparse} introduces the idea of an argument processor, which is
+% applied to an argument \emph{after} it has been grabbed by the
+% underlying system but before it is passed to \meta{code}. An argument
+% processor can therefore be used to regularise input at an early stage,
+% allowing the internal functions to be completely independent of input
+% form. Processors are applied to user input and to default values for
+% optional arguments, but \emph{not} to the special \cs{NoValue} marker.
+%
+% Each argument processor is specified by the syntax
+% \texttt{>}\marg{processor} in the argument specification. Processors
+% are applied from right to left, so that
+%\begin{verbatim}
+% >{\ProcessorB} >{\ProcessorA} m
+%\end{verbatim}
+% would apply \cs{ProcessorA}
+% followed by \cs{ProcessorB} to the tokens grabbed by the \texttt{m}
+% argument.
+%
+%\begin{variable}{\l_xparse_arg_toks}
+% \pkg{xparse} defines a very small set of processor functions. In the
+% main, it is anticipated that code writers will want to create their
+% own processors. These need to accept one argument, which is the
+% tokens as grabbed (or as returned by a previous processor function).
+% Processor functions should return the processed argument in the
+% variable \cs{l_xparse_arg_toks}. This will always be empty when the
+% processor function is called by \pkg{xparse}, even if more than one
+% argument processor is applied.
+%\end{variable}
+%
+%\begin{function}{\xparse_process_to_str:n}
+% \begin{syntax}
+% "\xparse_process_to_str:n" \Arg{grabbed argument}
+% \end{syntax}
+% The \cs{xparse_process_to_str:n} processor applies the \LaTeX3
+% \cs{tl_to_str:n} function to the <grabbed argument>. For example
+% \begin{verbatim}
+% \DeclareDocumentCommand \foo { >{\xparse_arg_to_str:n} m } {
+% #1 % Which is now detokenized
+% }
+% \end{verbatim}
+%\end{function}
+%
+%\begin{function}{\xparse_process_comma_split:n}
+% \begin{syntax}
+% "\xparse_process_comma_split:n"
+% ~~~~\Arg{grabbed argument}
+% \end{syntax}
+% The \cs{xparse_process_comma_split:n} processor splits the
+% grabbed argument at the first comma, returning the two
+% parts of the result in braces. If no comma is found, the second
+% part of the returned value \cs{NoValue}. This function is intended to
+% aid the processing of co-ordinate pairs. For example, to create
+% a co-ordinate argument which raises an error if not given:
+% \begin{verbatim}
+% \DeclareDocumentCommand \foo
+% { >{\xparse_process_comma_split:n} d() } {
+% \IfNoValueTF #1 {
+% \ERROR
+% }{
+% \foo_internal:nn #1
+% }
+% }
+% \end{verbatim}
+% For the input |\foo(1.1,2.2)|, |#1| here would equal |{1.1}{2.2}|,
+% and so \cs{foo_internal:nn} receives exactly the correct number of
+% arguments. A similar function which takes an optional co-ordinate
+% pair, could be created as:
+% \begin{verbatim}
+% \DeclareDocumentCommand \foo
+% { >{\xparse_process_comma_split:n} D(){0,0} } {
+% \foo_internal:nn #1
+% }
+% \end{verbatim}
+% This illustrates that the processor function will be applied to the
+% default value, which therefore includes a comma.
+%\end{function}
+%
+%\subsection{Separating interface and implementation}
+%
+% One \emph{experimental} idea implemented in \pkg{xparse} is to
+% separate out document command intefaces (the argument specification)
+% from the implementation (code). This is carried out using a
+% pair of functions, \cs{DeclareDocumentCommandInterface} and
+% \cs{DeclareDocumentCommandImplementation}
+%
+%\begin{function}{\DeclareDocumentCommandInterface}
+% \begin{syntax}
+% "\DeclareDocumentCommandInterface" <function>
+% ~~~~\Arg{implementation} \Arg{arg.~spec}
+% \end{syntax}
+% This declares a <function>, which will take arguments as detailed
+% in the <arg.~spec>. When executed, the <function> will look for
+% code stored as an <implementation>.
+%\end{function}
+%
+%\begin{function}{\DeclareDocumentCommandImplementation}
+% \begin{syntax}
+% "\DeclareDocumentCommandImplementation"
+% ~~~~\Arg{implementation} <args> \Arg{code}
+% \end{syntax}
+% Declares the <implementation> for a function to accept <args>
+% arguments and expand to <code>. An implementation must take the
+% same number of arguments as a linked interface, although this is not
+% enforced by the code.
+%\end{function}
+%
+%\subsection{Fully-expandable document commands}
+%
+% There are \emph{very rare} occasion when it may be useful to create
+% functions using a fully-expandable argument grabber. To support this,
+% \pkg{xparse} can create expandable functions as well as the usual
+% robust ones. This imposes a number of restrictions on the nature of
+% the arguments accepted by a function, and the code it implements.
+% This facility should only be used when \emph{absolutely necessary};
+% if you do not understand when this might be, \emph{do not use these
+% functions}!
+%
+%\begin{function}{\DeclareExpandableDocumentCommand}
+% \begin{syntax}
+% "\DeclareExpandableDocumentCommand"
+% ~~~~<function> \Arg{arg spec} \Arg{code}
+% \end{syntax}
+% This command is used to create a document-level <function>,
+% which will grab its arguments in a fully-expandable manner. The
+% argument specification for the function is given by <arg spec>,
+% and the function will execute <code>. In general, <code> will
+% also be fully expandable, although it is possible that this will
+% not be the case (for example, a function for use in a table might
+% expand so that \cs{omit} is the first non-expandable token).
+%
+% Parsing arguments expandably imposes a number of restrictions on
+% both the type of arguments that can be read and the error checking
+% available:
+% \begin{itemize}
+% \item The function must have at least one mandatory argument, and
+% in particular the last argument must be one of the mandatory
+% types (\texttt{l}, \texttt{m} or \texttt{u}).
+% \item All arguments are either short or long: it is not possible
+% to mix short and long argument types.
+% \item The `optional group' argument types \texttt{g} and
+% \texttt{G} are not available.
+% \item It is not possible to differentiate between, for example
+% |\foo[| and |\foo{[}|: in both cases the \texttt{[} will be
+% interpretted as the start of an optional argument. As a result
+% result, checking for optional arguments is less robust than
+% in the standard version.
+% \end{itemize}
+% \pkg{xparse} will issue an error if an argument specifier is given
+% which does not conform to the first three requirements. The last
+% item is an issue when the function is used, and so is beyond the
+% scope of \pkg{xparse} itself.
+%\end{function}
+%
+%\subsection{Variables and constants}
+%
+%\begin{variable}{\c_xparse_shorthands_prop}
+% Shorthands and replacement text: set up at the start of the package,
+% and not be be altered later!
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_args_toks}
+% Token register for arguments as they are picked up for passing on to
+% user functions.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_environment_args_toks}
+% Token register to pass arguments to the end of an environment from
+% the beginning.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_error_bool}
+% For flagging up errors when making expandable commands.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_function_tl}
+% Needed to pass along the function name when creating in an expandable
+% manner. This is needed as a series of functions have to be created
+% when making expandable functions. (In contrast, standard robust
+% functions need at most two functions.)
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_last_arg_tl}
+% The last argument type added. As this must be mandatory when creating
+% expandable commands, this variable is needed to enforce this
+% behaviour.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_long_bool}
+% Flag used to indicate creation of \cs{long} arguments.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_m_args_int}
+% Used to enumerate the \texttt{m} arguments with no modifications
+% (i.e., neither long nor processed after grabbing).
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_m_only_bool}
+% Flag used to indicate that all arguments are of type \texttt{m},
+% with no no modificiations.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_mandatory_args_int}
+% For counting up all mandatory arguments so that the code can tell
+% when optional arguments come after the last mandatory one. Counts
+% down again as mandatory arguments are added to the signature, so will
+% be zero for any trailing optional arguments.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_processor_bool}
+% When converting an argument specification into a signature there is
+% a need to know if there are any argument processors set up. This is
+% used to tell if \texttt{m} arguments can simply be counted up or need
+% handling on a one-off basis.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_processor_int}
+% Each time a processor is set up in the grabber routine, it is stored
+% and the total number of processors is recorded here. Later, the
+% variable is counted back down to use the processors in reverse order
+% to the collection order.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_signature_toks}
+% For constucting the signature of the function defined. As
+% \pkg{xparse} works thorugh an argument specification, grabber
+% functions are added to this toks for each argument.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_tmp_tl}
+% Scratch space, used for example to convert shorthand argument types
+% into the full versions.
+%\end{variable}
+%
+%\begin{variable}{\l_xparse_total_args_int}
+% Used to enumerate the total number of arguments (i.e., the number of
+% ingroup letters in the argument specification).
+%\end{variable}
+%
+%\begin{variable}{\q_xparse_stop}
+% A private delimiting quark: needed by the expandable function system.
+%\end{variable}
+%
+%\subsection{Internal functions}
+%
+%\begin{function}{\xparse_add_arg:n}
+% \begin{syntax}
+% "\xparse_add_arg:n" <grabbed arg>
+% \end{syntax}
+% Adds <grabbed arg> to the output \pkg{xparse} supplies to the
+% defined <code>, applying any post-processing that is needed.
+%\end{function}
+%
+%\begin{function}{
+% \xparse_add_grabber_mandatory:N|
+% \xparse_add_grabber_optional:N
+%}
+% \begin{syntax}
+% "\xparse_add_grabber_mandatory:N" <grabber type>
+% \end{syntax}
+% Adds appropriate grabber for <grabber type> to the signature
+% being constructed, making it long if necessary. The
+% \texttt{optional} version includes a second check to see if space
+% skipping should be on or off.
+%\end{function}
+%
+%\begin{function}{
+% \xparse_add_type_+:w|
+% \xparse_add_type_>:w|
+% \xparse_add_type_d:w|
+% \xparse_add_type_D:w|
+% \xparse_add_type_g:w|
+% \xparse_add_type_G:w|
+% \xparse_add_type_l:w|
+% \xparse_add_type_m:w|
+% \xparse_add_type_t:w|
+% \xparse_add_type_u:w
+%}
+% \begin{syntax}
+% "\xparse_add_type_u:w"
+% \end{syntax}
+% Carry out necessary processes to add given <type> of argument to
+% the signature being constructed. Depending on the argument type
+% being added, one or more arguments will be absorbed.
+%\end{function}
+%
+%\begin{function}{\xparse_check_and_add:N}
+% \begin{syntax}
+% "\xparse_check_and_add:N" <arg spec>
+% \end{syntax}
+% Ensures that <arg spec> is valid, and if so adds it to the signature
+% being constructed.
+%\end{function}
+%
+%\begin{function}{
+% \xparse_count_mandatory:n|
+% \xparse_count_mandatory:N
+%}
+% \begin{syntax}
+% "\xparse_count_mandatory:N" <arg spec>
+% \end{syntax}
+% Used to count how many mandatory arguments an argument specification
+% contains. The \texttt{n} function carries out the set up, before
+% handing of to the \texttt{N} function. This reads one token, and
+% calls the approriate counter function.
+%\end{function}
+%
+%\begin{function}{
+% \xparse_count_type_>:w|
+% \xparse_count_type_+:w|
+% \xparse_count_type_d:w|
+% \xparse_count_type_D:w|
+% \xparse_count_type_g:w|
+% \xparse_count_type_G:w|
+% \xparse_count_type_l:w|
+% \xparse_count_type_m:w|
+% \xparse_count_type_t:w|
+% \xparse_count_type_u:w|
+%}
+% \begin{syntax}
+% "\xparse_count_type_D:w"
+% \end{syntax}
+% Used to count up mandatory arguments: one function for each argument
+% type so that a simple loop can be used. Only the functions for
+% mandatory arguments do any more than call the loop again.
+%\end{function}
+%
+%\begin{function}{
+% \xparse_declare_cmd:Nnn|
+% \xparse_declare_cmd:cnn
+%}
+% \begin{syntax}
+% "\xparse_declare_cmd:Nnn" <function> \Arg{signature}
+% ~~~~\Arg{code}
+% \end{syntax}
+% Declares <function> using <signature> for argument definition and
+% <code> as expansion.
+% \begin{texnote}
+% This is the internal name for \cs{DeclareDocumentCommand}.
+% \end{texnote}
+%\end{function}
+%
+%\begin{function}{\xparse_declare_cmd_interface:Nnn}
+% \begin{syntax}
+% "\xparse_declare_cmd_interface:Nnn" <function>
+% ~~~~\Arg{implementation} \Arg{signature}
+% \end{syntax}
+% Declares <function> using <signature>, which should have code stored
+% as <implementation>.
+% \begin{texnote}
+% This is the internal name for \cs{DeclareDocumentCommandInterface}.
+% \end{texnote}
+%\end{function}
+%
+%\begin{function}{\xparse_declare_cmd_implementation:nNn}
+% \begin{syntax}
+% "\xparse_declare_cmd_implementation:nNn"
+% ~~~~\Arg{implementation} <number> \Arg{code}
+% \end{syntax}
+% Declares <code> taking <number> arguments as an <implementation>,
+% to be accessed using an interface defined elsewhere.
+% \begin{texnote}
+% This is the internal name for
+% \cs{DeclareDocumentCommandImplementation}.
+% \end{texnote}
+%\end{function}
+%
+%\begin{function}{\xparse_declare_env:nnnn}
+% \begin{syntax}
+% "\xparse_declare_env:nnnn" \Arg{env} \Arg{arg spec}
+% ~~~~\Arg{start code} \Arg{end code}
+% \end{syntax}
+% Declares <env> as an environment taking <arg spec> arguments
+% at \cs{begin}\{<env>\}. The <start code> is eceutre at the beginning
+% of the environment, and the <end code> at the end. Both parts may
+% use the arguments defined by <arg spec>.
+% \begin{texnote}
+% This is the internal name for \cs{DeclareDocumentEnvironment}.
+% \end{texnote}
+%\end{function}
+%
+%\begin{function}{\xparse_flush_m_args:}
+% \begin{syntax}
+% "\xparse_flush_m_args:"
+% \end{syntax}
+% Adds an outstanding \texttt{m} arguments to the signature.
+%\end{function}
+%
+%\begin{function}{\xparse_grab_arg:w}
+% \begin{syntax}
+% "\xparse_grab_arg:w" <args>
+% \end{syntax}
+% Function re-defined each time an argument is grabbed to actually
+% do the grabbing. It is this function which will raise an error if
+% an argument runs away.
+%\end{function}
+%
+%\begin{function}{
+% \xparse_grab_D:w |
+% \xparse_grab_D_long:w |
+% \xparse_grab_D_trailing:w |
+% \xparse_grab_D_long_trailing:w|
+% \xparse_grab_G:w |
+% \xparse_grab_G_long:w |
+% \xparse_grab_G_trailing:w |
+% \xparse_grab_G_long_trailing:w|
+% \xparse_grab_l:w |
+% \xparse_grab_l_long:w |
+% \xparse_grab_m:w |
+% \xparse_grab_m_long:w |
+% \xparse_grab_m_1:w |
+% \xparse_grab_m_2:w |
+% \xparse_grab_m_3:w |
+% \xparse_grab_m_4:w |
+% \xparse_grab_m_5:w |
+% \xparse_grab_m_6:w |
+% \xparse_grab_m_7:w |
+% \xparse_grab_m_8:w |
+% \xparse_grab_t:w |
+% \xparse_grab_t_long:w |
+% \xparse_grab_t_trailing:w |
+% \xparse_grab_t_long_trailing:w|
+% \xparse_grab_u:w |
+% \xparse_grab_u_long:w |
+%}
+% \begin{syntax}
+% "\xparse_grab_D:w" <arg data> "\l_xparse_args_toks"
+% \end{syntax}
+% Argument grabbing functions, which re-arrange other <arg data>
+% so that the argument is read correctly. The \texttt{trailing}
+% versions do not skip spaces when searching for optional arguments.
+% For each argument type, the various versions feed the approriate
+% information to a common auxiliary function which then sets up
+% \cs{xparse_grab_arg:w} to actually carry out the argument absorption.
+%\end{function}
+%
+%\begin{function}{\xparse_if_no_value:n / (TF) (EXP)}
+% \begin{syntax}
+% "\xparse_if_no_value:nTF" \Arg{arg}
+% ~~~~\Arg{true code} \Arg{false code}
+% \end{syntax}
+% Executes <true code> if <arg> is equal to the special
+% \cs{NoValue} marker and <false code> otherwise. Provided that
+% the primitive \cs{(pdf)strcmp} is available, this function is
+% expandable.
+%\end{function}
+%
+%\begin{function}{
+% \xparse_prepare_signature:n|
+% \xparse_prepare_signature:N
+%}
+% \begin{syntax}
+% "\xparse_prepare_signature:n" \Arg{arg specs}
+% \end{syntax}
+% Parse one or more <arg specs> and convert to an output <signature>.
+%\end{function}
+%
+%\begin{function}{\xparse_process_arg:n}
+% \begin{syntax}
+% "\xparse_process_arg:n" \Arg{processor}
+% \end{syntax}
+% Sets up code to apply <processor> to next grabbed argument.
+%\end{function}
+%
+%\subsection{Creating expandable commands}
+%
+%\begin{function}{
+% \xparse_exp_add_type_d:w|
+% \xparse_exp_add_type_D:w|
+% \xparse_exp_add_type_l:w|
+% \xparse_exp_add_type_m:w|
+% \xparse_exp_add_type_t:w|
+% \xparse_exp_add_type_u:w
+%}
+% \begin{syntax}
+% "\xparse_exp_add_type_u:w" \Arg{delimiter}
+% \end{syntax}
+% Carry out necessary processes to add given <type> of argument for
+% an expandable command. Depending on the argument type being added,
+% one or more arguments will be absorbed.
+%\end{function}
+%
+%\begin{function}{\xparse_exp_check_and_add:N}
+% \begin{syntax}
+% "\xparse_exp_check_and_add:N" <arg spec>
+% \end{syntax}
+% Ensures that <arg spec> is valid, and if so adds it to expandable
+% function being constructed.
+%\end{function}
+%
+%\begin{function}{\xparse_exp_declare_cmd:Nnn}
+% \begin{syntax}
+% "\xparse_exp_declare_cmd:Nnn" <function> \Arg{signature}
+% ~~~~\Arg{code}
+% \end{syntax}
+% Declares <function> using <signature> for argument definition and
+% <code> as expansion, and creating an expandable command.
+% \begin{texnote}
+% This is the internal name for
+% \cs{DeclareExpandableDocumentCommand}.
+% \end{texnote}
+%\end{function}
+%
+%\begin{function}{
+% \xparse_exp_prepare_function:n|
+% \xparse_exp_prepare_function:N
+%}
+% \begin{syntax}
+% "\xparse_exp_prepare_function:n" \Arg{arg specs}
+% \end{syntax}
+% Parse one or more <arg specs> and convert to an expandable
+% function.
+%\end{function}
+%
+%\begin{function}{\xparse_exp_set:cpx}
+% \begin{syntax}
+% "\xparse_exp_set:cpx" <csname> <parameters> \Arg{code}
+% \end{syntax}
+% An alias for either \cs{cs_set:cpx} or \cs{cs_set_nopar:cpx},
+% depending on the \cs{long} status of the expandable function.
+%\end{function}
+%
+%\end{documentation}
+%
+%\begin{implementation}
+%
+%\section{\pkg{xparse} implementation}
+%
+% The usual lead-off: only needed for the package, of course (one day we
+% may have a \LaTeX3 kernel).
+% \begin{macrocode}
+%<*package>
+\ProvidesExplPackage
+ {\filename}{\filedate}{\fileversion}{\filedescription}
+\RequirePackage{expl3}
+%</package>
+%<*initex|package>
+% \end{macrocode}
+%
+%\subsection{Variables and constants}
+%
+%\begin{macro}{\c_xparse_shorthands_prop}
+% Shorthands are stored as a property list: this is set up here as it
+% is a constant.
+% \begin{macrocode}
+\prop_new:N \c_xparse_shorthands_prop
+\prop_put:Nnn \c_xparse_shorthands_prop { o } { d[] }
+\prop_put:Nnn \c_xparse_shorthands_prop { O } { D[] }
+\prop_put:Nnn \c_xparse_shorthands_prop { s } { t* }
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_arg_toks}
+% Token registers for single grabbed argument when post-processing.
+% \begin{macrocode}
+\toks_new:N \l_xparse_arg_toks
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_args_toks}
+% Token registers for grabbed arguments.
+% \begin{macrocode}
+\toks_new:N \l_xparse_args_toks
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_environment_args_toks}
+% Used to pass arguments to the end of an environment.
+% \begin{macrocode}
+\toks_new:N \l_xparse_environment_args_toks
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_error_bool}
+% Used to signal an error when creating expandable functions.
+% \begin{macrocode}
+\bool_new:N \l_xparse_error_bool
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_function_tl}
+% When creating expandable functions, the current function name needs
+% to be passed along.
+% \begin{macrocode}
+\tl_new:N \l_xparse_function_tl
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_last_arg_tl}
+% Used when creating expandable arguments.
+% \begin{macrocode}
+\toks_new:N \l_xparse_last_arg_tl
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_long_bool}
+% A flag for \cs{long} arguments.
+% \begin{macrocode}
+\bool_new:N \l_xparse_long_bool
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_m_args_int}
+% The number of simple \texttt{m} arguments is tracked so they can be
+% dumped \emph{en masse}.
+% \begin{macrocode}
+\int_new:N \l_xparse_m_args_int
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_m_only_bool}
+% A flag to indicate that only \texttt{m} arguments have been found.
+% \begin{macrocode}
+\bool_new:N \l_xparse_m_only_bool
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_mandatory_args_int}
+% So that trailing optional arguments can be picked up, a count has to
+% be taken of all mandatory arguments. This is then decreased as
+% mandatory arguments are added to the signature, so will be zero
+% only if there are no more mandatory arguments to add.
+% \begin{macrocode}
+\int_new:N \l_xparse_mandatory_args_int
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_processor_bool}
+% When reading through the argument specifier, a flag is needed to
+% show that a processor has been found for the current argument. This
+% is used when checking how to handle \texttt{m} arguments.
+% \begin{macrocode}
+\bool_new:N \l_xparse_processor_bool
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_processor_int}
+% In the grabber routine, each processor is saved with a number
+% recording the order it was found in. The total is then used to work
+% back through the grabbers so they apply to the argument right to left.
+% \begin{macrocode}
+\int_new:N \l_xparse_processor_int
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_signature_toks}
+% Token registers for constructing signatures.
+% \begin{macrocode}
+\toks_new:N \l_xparse_signature_toks
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_tmp_tl}
+% A general purpose token list variable.
+% \begin{macrocode}
+\tl_new:N \l_xparse_tmp_tl
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\l_xparse_total_args_int}
+% Thje total number of arguments is used to create the internal function
+% which has a fixed number of arguments.
+% \begin{macrocode}
+\int_new:N \l_xparse_total_args_int
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\q_xparse_stop}
+% A private quark, used for delimiting arguments when making
+% expandable functions.
+% \begin{macrocode}
+\quark_new:N \q_xparse_stop
+% \end{macrocode}
+%\end{macro}
+%
+%\subsection{Turning the argument specifier into grabbers}
+%
+%\begin{macro}{\xparse_add_grabber_mandatory:N}
+%\begin{macro}{\xparse_add_grabber_optional:N}
+% To keep the various checks needed in one place, adding the grabber to
+% the signature is done here. For mandatory arguments, the only question
+% is whether to add a long grabber. For optional arguments, there is
+% also a check to see if any mandatory arguments are still to be added.
+% This is used to determine whether to skip spaces or not where
+% searching for the argument.
+% \begin{macrocode}
+\cs_new_nopar:Nn \xparse_add_grabber_mandatory:N {
+ \toks_put_right:Nx \l_xparse_signature_toks {
+ \exp_not:c {
+ xparse_grab_ #1 \bool_if:NT \l_xparse_long_bool { _long } :w
+ }
+ }
+ \bool_set_false:N \l_xparse_long_bool
+ \int_decr:N \l_xparse_mandatory_args_int
+}
+\cs_new_nopar:Nn \xparse_add_grabber_optional:N {
+ \toks_put_right:Nx \l_xparse_signature_toks {
+ \exp_not:c {
+ xparse_grab_ #1
+ \bool_if:NT \l_xparse_long_bool { _long }
+ \intexpr_compare:nF {
+ \l_xparse_mandatory_args_int > \c_zero
+ } { _trailing }
+ :w
+ }
+ }
+ \bool_set_false:N \l_xparse_long_bool
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+% All of the argument-adding functions work in essentially the same
+% way, except the one for \texttt{m} arguments. Any collected \texttt{m}
+% arguments are added to the signature, then the appropriate grabber
+% is added to the signature. Some of the adding functions also pick up
+% one or more arguments, and are also added to the signature. All of the
+% functions then call the loop function \cs{xparse_prepare_signature:N}.
+%
+%\begin{macro}{\xparse_add_type_+:w}
+% Making the next argument \cs{long} means setting the flag and
+% knocking one back off the totatl argument count. The \texttt{m}
+% arguments are recorded here as this has to be done for every case
+% where there is then a \cs{long} argument.
+% \begin{macrocode}
+\cs_new_nopar:cpn { xparse_add_type_+:w } {
+ \xparse_flush_m_args:
+ \bool_set_true:N \l_xparse_long_bool
+ \bool_set_false:N \l_xparse_m_only_bool
+ \int_decr:N \l_xparse_total_args_int
+ \xparse_prepare_signature:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_>:w}
+% When a processor is found, the function \cs{xparse_process_arg:n}
+% is added to the signature along with the processor code itself. When
+% the signature is used, the code will be added to an excution list by
+% \cs{xparse_process_arg:n}. Here, the loop calls
+% \cs{xparse_prepare_signature_aux:N} rather than
+% \cs{xparse_prepare_signature:N} so that the flag is not reset.
+% \begin{macrocode}
+\cs_new:cpn { xparse_add_type_>:w } #1 {
+ \bool_set_true:N \l_xparse_processor_bool
+ \xparse_flush_m_args:
+ \int_decr:N \l_xparse_total_args_int
+ \toks_put_right:Nn \l_xparse_signature_toks {
+ \xparse_process_arg:n {#1}
+ }
+ \xparse_prepare_signature_aux:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_d:w}
+% To save on repeated code, \texttt{d} is actually turned into
+% the same grabber as is used by \texttt{D}, by putting the
+% \cs{NoValue} default in the correct place. So there is some
+% simple argument re-arrangement to do. Remember that |#1| and |#2|
+% shoudl be single tokens.
+% \begin{macrocode}
+\cs_new:Npn \xparse_add_type_d:w #1#2 {
+ \xparse_add_type_D:w #1 #2 { \NoValue }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_D:w}
+% All of the optional delimited arguments are handled internally by
+% the \texttt{D} type. At this stage, the two delimiters are stored
+% along with the default value.
+% \begin{macrocode}
+\cs_new:Npn \xparse_add_type_D:w #1#2#3 {
+ \xparse_flush_m_args:
+ \xparse_add_grabber_optional:N D
+ \toks_put_right:Nn \l_xparse_signature_toks { #1 #2 {#3} }
+ \xparse_prepare_signature:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_g:w}
+% The \texttt{g} type is simply an alias for \texttt{G} with the
+% correct default built-in.
+% \begin{macrocode}
+\cs_new_nopar:Npn \xparse_add_type_g:w {
+ \xparse_add_type_G:w { \NoValue }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_G:w}
+% For the \texttt{G} type, the grabber and the default are added to
+% the signature.
+% \begin{macrocode}
+\cs_new:Npn \xparse_add_type_G:w #1 {
+ \xparse_flush_m_args:
+ \xparse_add_grabber_optional:N G
+ \toks_put_right:Nn \l_xparse_signature_toks { {#1} }
+ \xparse_prepare_signature:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_l:w}
+% Finding \texttt{l} arguments is very simple: there is nothing to do
+% other than add the grabber.
+% \begin{macrocode}
+\cs_new_nopar:Npn \xparse_add_type_l:w {
+ \xparse_flush_m_args:
+ \xparse_add_grabber_mandatory:N l
+ \xparse_prepare_signature:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_m:w}
+% The \texttt{m} type is special as short arguments which are not
+% post-processed are simply counted at this stage. Thus there is a check
+% to see if either of these cases apply. If so, a one-argument grabber
+% is added to the signature. On the other hand, if a standard short
+% argument is required it is simply counted at this stage, to be
+% added later using \cs{xparse_flush_m_args:}.
+% \begin{macrocode}
+\cs_new_nopar:Npn \xparse_add_type_m:w {
+ \bool_if:nTF {
+ \l_xparse_long_bool || \l_xparse_processor_bool
+ } {
+ \xparse_flush_m_args:
+ \xparse_add_grabber_mandatory:N m
+ }{
+ \int_incr:N \l_xparse_m_args_int
+ }
+ \xparse_prepare_signature:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_t:w}
+% Setting up a \texttt{t} argument means collecting one token for the
+% test, and adding it along with the grabber to the signature.
+% \begin{macrocode}
+\cs_new:Npn \xparse_add_type_t:w #1 {
+ \xparse_flush_m_args:
+ \xparse_add_grabber_optional:N t
+ \toks_put_right:Nn \l_xparse_signature_toks { #1 }
+ \xparse_prepare_signature:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_add_type_u:w}
+% At the set up stage, the \texttt{u} type argument is identical to the
+% \texttt{G} type except for the name of the grabber function.
+% \begin{macrocode}
+\cs_new:Npn \xparse_add_type_u:w #1 {
+ \xparse_flush_m_args:
+ \xparse_add_grabber_mandatory:N u
+ \toks_put_right:Nn \l_xparse_signature_toks { {#1} }
+ \xparse_prepare_signature:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_check_and_add:N}
+% This function checks if the argument type actually exists and gives
+% an error if it doesn't.
+% \begin{macrocode}
+\cs_new_nopar:Nn \xparse_check_and_add:N {
+ \cs_if_free:cTF { xparse_add_type_ #1 :w } {
+ \msg_error:nnx { xparse } { unknown-argument-type } {#1}
+ \xparse_add_type_m:w
+ }{
+ \use:c { xparse_add_type_ #1 :w }
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_count_mandatory:n}
+%\begin{macro}{\xparse_count_mandatory:N}
+%\begin{macro}[aux]{\xparse_count_mandatory_aux:N}
+% To count up mandatory arguments before the main parsing run, the
+% same approach is used. First, check if the current token is a
+% shrot-cut for another argument type. If it is, expand it and loop
+% again. If not, then look for a `counting' function to check the
+% argument type. No error is raised here if one is not found as one
+% will be raised by later code.
+% \begin{macrocode}
+\cs_new:Nn \xparse_count_mandatory:n {
+ \int_zero:N \l_xparse_mandatory_args_int
+ \xparse_count_mandatory:N #1 \q_nil
+}
+\cs_new:Nn \xparse_count_mandatory:N {
+ \quark_if_nil:NF #1 {
+ \prop_if_in:NnTF \c_xparse_shorthands_prop {#1} {
+ \prop_get:NnN \c_xparse_shorthands_prop {#1} \l_xparse_tmp_tl
+ \exp_last_unbraced:NV \xparse_count_mandatory:N \l_xparse_tmp_tl
+ }{
+ \xparse_count_mandatory_aux:N #1
+ }
+ }
+}
+\cs_new:Nn \xparse_count_mandatory_aux:N {
+ \cs_if_free:cTF { xparse_count_type_ #1 :w } {
+ \xparse_count_type_m:w
+ }{
+ \use:c { xparse_count_type_ #1 :w }
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_count_type_>:w}
+%\begin{macro}{\xparse_count_type_+:w}
+%\begin{macro}{\xparse_count_type_d:w}
+%\begin{macro}{\xparse_count_type_D:w}
+%\begin{macro}{\xparse_count_type_g:w}
+%\begin{macro}{\xparse_count_type_G:w}
+%\begin{macro}{\xparse_count_type_l:w}
+%\begin{macro}{\xparse_count_type_m:w}
+%\begin{macro}{\xparse_count_type_t:w}
+%\begin{macro}{\xparse_count_type_u:w}
+% For counting the mandatory arguments, a function is provided for
+% each argument type that will mop any extra arguments and call the
+% loop function. Only the counting functions for mandatory arguments
+% actually do anything: the rest are simply there to ensure the loop
+% continues correctly.
+% \begin{macrocode}
+\cs_new:cpn { xparse_count_type_>:w } #1 {
+ \xparse_count_mandatory:N
+}
+\cs_new_nopar:cpn { xparse_count_type_+:w } {
+ \xparse_count_mandatory:N
+}
+\cs_new:Npn \xparse_count_type_d:w #1#2 {
+ \xparse_count_mandatory:N
+}
+\cs_new:Npn \xparse_count_type_D:w #1#2#3 {
+ \xparse_count_mandatory:N
+}
+\cs_new_nopar:Npn \xparse_count_type_g:w {
+ \xparse_count_mandatory:N
+}
+\cs_new:Npn \xparse_count_type_G:w #1 {
+ \xparse_count_mandatory:N
+}
+\cs_new_nopar:Npn \xparse_count_type_l:w {
+ \int_incr:N \l_xparse_mandatory_args_int
+ \xparse_count_mandatory:N
+}
+\cs_new_nopar:Npn \xparse_count_type_m:w {
+ \int_incr:N \l_xparse_mandatory_args_int
+ \xparse_count_mandatory:N
+}
+\cs_new:Npn \xparse_count_type_t:w #1 {
+ \xparse_count_mandatory:N
+}
+\cs_new:Npn \xparse_count_type_u:w #1 {
+ \int_incr:N \l_xparse_mandatory_args_int
+ \xparse_count_mandatory:N
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_declare_cmd:Nnn}
+%\begin{macro}{\xparse_declare_cmd:cnn}
+%\begin{macro}[aux]{\xparse_declare_cmd_all_m:Nn}
+%\begin{macro}[aux]{\xparse_declare_cmd_mixed:Nn}
+% First, the signature is set up from the argument specification. There
+% is then a check: if only \texttt{m} arguments are needed (which
+% includes functions with no arguments at all) then the definition is
+% simple. On the other hand, if the signature is more complex then an
+% internal function actually contains the code with the user function
+% as a simple wrapper.
+% \begin{macrocode}
+\cs_new:Nn \xparse_declare_cmd:Nnn {
+ \xparse_count_mandatory:n {#2}
+ \xparse_prepare_signature:n {#2}
+ \bool_if:NTF \l_xparse_m_only_bool {
+ \xparse_declare_cmd_all_m:Nn #1 {#3}
+ }{
+ \xparse_declare_cmd_mixed:Nn #1 {#3}
+ }
+}
+\cs_generate_variant:Nn \xparse_declare_cmd:Nnn { cnn }
+\cs_new:Nn \xparse_declare_cmd_all_m:Nn {
+ \cs_generate_from_arg_count:NNnn
+ #1 \cs_set_protected_nopar:Npn \l_xparse_total_args_int {#2}
+}
+\cs_new:Nn \xparse_declare_cmd_mixed:Nn {
+ \cs_set_protected_nopar:Npx #1 {
+ \exp_not:n {
+ \int_zero:N \l_xparse_processor_int
+ \toks_set:Nn \l_xparse_args_toks
+ } { \exp_not:c { \token_to_str:N #1 } }
+ \toks_use:N \l_xparse_signature_toks
+ \exp_not:n{ \toks_use:N \l_xparse_args_toks }
+ }
+ \cs_generate_from_arg_count:cNnn
+ { \token_to_str:N #1 } \cs_set:Npn \l_xparse_total_args_int {#2}
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_declare_cmd_implementation:nNn}
+% Creating a stand-alone implementation uisn the `two-part' mechanism
+% is quite easy as this is just a wrapper for
+% \cs{cs_generate_from_arg_count:cNnn}.
+% \begin{macrocode}
+\cs_new:Nn \xparse_declare_cmd_implementation:nNn {
+ \cs_generate_from_arg_count:cNnn { implementation_ #1 :w }
+ \cs_set:Npn {#2} {#3}
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_declare_cmd_interface:Nnn}
+%\begin{macro}[aux]{\xparse_declare_cmd_interface_all_m:Nn}
+%\begin{macro}[aux]{\xparse_declare_cmd_interface_mixed:Nn}
+% As with the basic function \cs{xparse_declare_cmd:Nnn}, there are
+% three things to do here. First, generate a signature from the
+% argument specification. Then use that to create a function which
+% will call the implementation part. Finally, a holder implementation
+% is created. As before, there is a short-cut for functions which only
+% have \texttt{m} type arguments.
+% \begin{macrocode}
+\cs_new:Nn \xparse_declare_cmd_interface:Nnn {
+ \xparse_prepare_signature:n {#3}
+ \bool_if:NTF \l_xparse_m_only_bool {
+ \xparse_declare_cmd_interface_all_m:Nn #1 {#2}
+ }{
+ \xparse_declare_cmd_interface_mixed:Nn #1 {#2}
+ }
+ \cs_generate_from_arg_count:cNnn { implementation_ #2 :w }
+ \cs_set:Npn \l_xparse_total_args_int { ``#2'' }
+}
+\cs_new:Nn \xparse_declare_cmd_interface_all_m:Nn {
+ \cs_generate_from_arg_count:NNnn
+ #1 \cs_set_protected_nopar:Npn \l_xparse_total_args_int
+ { \use:c { implementation_ #2 :w } }
+}
+\cs_new:Nn \xparse_declare_cmd_interface_mixed:Nn {
+ \cs_set_protected_nopar:Npx #1 {
+ \exp_not:n {
+ \int_zero:N \l_xparse_processor_int
+ \toks_set:Nn \l_xparse_args_toks
+ } { \exp_not:c { \token_to_str:N #1 } }
+ \toks_use:N \l_xparse_signature_toks
+ \exp_not:n{ \toks_use:N \l_xparse_args_toks }
+ }
+ \cs_generate_from_arg_count:cNnn
+ { \token_to_str:N #1 } \cs_set:Npn \l_xparse_total_args_int
+ { \use:c { implementation_ #2 :w } }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_declare_env:nnnn}
+% The idea here is to make sure that the end of the environment has the
+% same arguments available as the beginning.
+% \begin{macrocode}
+\cs_new:Nn \xparse_declare_env:nnnn {
+ \xparse_declare_cmd:cnn { environment_begin_ #1 :w } {#2} {
+ \group_begin:
+ \toks_set_eq:NN \l_xparse_environment_args_toks
+ \l_xparse_args_toks
+ #3
+ }
+ \cs_set_nopar:cpx { environment_end_ #1 :w } {
+ \exp_not:N \exp_last_unbraced:NV
+ \exp_not:c { environment_end_ #1 _aux:N }
+ \exp_not:N \l_xparse_environment_args_toks
+ \exp_not:N \group_end:
+ }
+ \cs_set_nopar:cx { environment_end_ #1 _aux:N } {
+ \exp_not:c { environment_end_ #1 _aux :w }
+ }
+ \cs_generate_from_arg_count:cNnn
+ { environment_end_ #1 _aux :w } \cs_set:Npn
+ \l_xparse_total_args_int {#4}
+%</initex|package>
+%<*package>
+ \cs_set_eq:cc {#1} { environment_begin_ #1 :w }
+ \cs_set_eq:cc { end #1 } { environment_end_ #1 :w }
+%</package>
+%<*initex|package>
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_flush_m_args:}
+% As \texttt{m} arguments are simply counted, there is a need to add
+% them to the token register in a block. As this function can only
+% be called if something other than \texttt{m} turns up, the flag can
+% be switched here. The total number of mandatory arguments added to
+% the signature is also decreased by the appropriate amount.
+% \begin{macrocode}
+\cs_new_nopar:Nn \xparse_flush_m_args: {
+ \cs_if_exist:cT {
+ xparse_grab_m_ \int_use:N \l_xparse_m_args_int :w
+ } {
+ \toks_put_right:Nx \l_xparse_signature_toks {
+ \exp_not:c { xparse_grab_m_ \int_use:N \l_xparse_m_args_int :w }
+ }
+ \int_set:Nn \l_xparse_mandatory_args_int {
+ \l_xparse_mandatory_args_int - \l_xparse_m_args_int
+ }
+ }
+ \int_zero:N \l_xparse_m_args_int
+ \bool_set_false:N \l_xparse_m_only_bool
+}
+% \end{macrocode}
+%\end{macro}
+%
+%
+%\begin{macro}[TF]{\xparse_if_no_value:n}
+% Tests for \cs{NoValue}.
+% \begin{macrocode}
+\prg_new_conditional:Nnn \xparse_if_no_value:n { TF,T,F } {
+ \tl_if_eq:nnTF {#1} { \NoValue } {
+ \prg_return_true:
+ }{
+ \prg_return_false:
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_prepare_signature:n}
+% Creating the signature is a case of working through the input and
+% turning into the output in \cs{l_xparse_signature_toks}. A track is
+% also kept of the total number of arguments. This function sets
+% everything up then hands off to the parser.
+% \begin{macrocode}
+\cs_new:Nn \xparse_prepare_signature:n {
+ \bool_set_false:N \l_xparse_long_bool
+ \int_zero:N \l_xparse_m_args_int
+ \bool_set_true:N \l_xparse_m_only_bool
+ \bool_set_false:N \l_xparse_processor_bool
+ \toks_clear:N \l_xparse_signature_toks
+ \int_zero:N \l_xparse_total_args_int
+ \xparse_prepare_signature:N #1 \q_nil
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_prepare_signature:N}
+%\begin{macro}[aux]{\xparse_prepare_signature_aux:N}
+% The main signature-preparation loop is in two parts, to keep the code
+% a little clearer. Most of the checks here is pretty clear, with a key
+% point to watch what is next on the stack so that the loop continues
+% correctly.
+% \begin{macrocode}
+\cs_new:Nn \xparse_prepare_signature:N {
+ \bool_set_false:N \l_xparse_processor_bool
+ \xparse_prepare_signature_aux:N #1
+}
+\cs_new:Nn \xparse_prepare_signature_aux:N {
+ \quark_if_nil:NTF #1 {
+ \bool_if:NF \l_xparse_m_only_bool {
+ \xparse_flush_m_args:
+ }
+ }{
+ \prop_if_in:NnTF \c_xparse_shorthands_prop {#1} {
+ \prop_get:NnN \c_xparse_shorthands_prop {#1} \l_xparse_tmp_tl
+ \exp_last_unbraced:NV \xparse_prepare_signature:N \l_xparse_tmp_tl
+ }{
+ \int_incr:N \l_xparse_total_args_int
+ \xparse_check_and_add:N #1
+ }
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_process_arg:n}
+% Processors are saved for use later during the grabbbing process.
+% \begin{macrocode}
+\cs_new:Nn \xparse_process_arg:n {
+ \int_incr:N \l_xparse_processor_int
+ \cs_set:cn {
+ xparse_processor_ \int_use:N \l_xparse_processor_int :n
+ }
+ { #1 {##1} }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\subsection{Grabbing arguments}
+%
+%\begin{macro}{\xparse_add_arg:n}
+%\begin{macro}[aux]{\xparse_add_arg_aux:n}
+%\begin{macro}[aux]{\xparse_add_arg_aux:V}
+% The argument-storing system provides a single point for interfacing
+% with processors. They are done in a loop, couning downward. In this
+% way, the processor which was found last is executed first. The result
+% is that processors apply from right to left, as intended. Notice that
+% a set of braces are added back around the result of processing so that
+% the internal function will correctly pick up one argument for each
+% input argument.
+% \begin{macrocode}
+\cs_new:Nn \xparse_add_arg:n {
+ \intexpr_compare:nTF { \l_xparse_processor_int = \c_zero } {
+ \toks_put_right:Nn \l_xparse_args_toks { {#1} }
+ }{
+ \xparse_if_no_value:nTF {#1} {
+ \int_zero:N \l_xparse_processor_int
+ \toks_put_right:Nn \l_xparse_args_toks { {#1} }
+ }{
+ \xparse_add_arg_aux:n {#1}
+ }
+ }
+}
+\cs_new:Nn \xparse_add_arg_aux:n {
+ \use:c { xparse_processor_ \int_use:N \l_xparse_processor_int :n }
+ {#1}
+ \int_decr:N \l_xparse_processor_int
+ \intexpr_compare:nTF { \l_xparse_processor_int = \c_zero } {
+ \toks_put_right:No \l_xparse_args_toks {
+ \exp_after:wN { \toks_use:N \l_xparse_arg_toks }
+ }
+ }{
+ \xparse_add_arg_aux:V \l_xparse_arg_toks
+ }
+}
+\cs_generate_variant:Nn \xparse_add_arg_aux:n { V }
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+% All of the grabbers follow the same basic pattern. The intial function
+% sets u the appropriate information to define \cs{parse_grab_arg:w} to
+% grab the argument. This means determining whether to use
+% \cs{cs_set:Npn} or \cs{cs_set_nopar:Npn}, and for optional arguments
+% whether to skip spaces. In all cases, \cs{xparse_grab_arg:w} is then
+% called to actually do the grabbing.
+%
+%\begin{macro}{\xparse_grab_arg:w}
+% Each time an argument is actually grabbed, \pkg{xparse} defines a
+% function to do it. In that way, long arguments from previous functions
+% can be included in the definition of the grabber function, so that
+% it does not raise an error if not long. The generic function used
+% for this is reserved here.
+% \begin{macrocode}
+\cs_new:Npn \xparse_grab_aux:w { }
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_grab_D:w}
+%\begin{macro}{\xparse_grab_D_long:w}
+%\begin{macro}{\xparse_grab_D_trailing:w}
+%\begin{macro}{\xparse_grab_D_long_trailing:w}
+%\begin{macro}[aux]{\xparse_grab_D_aux:NNnnNn}
+% The generic delimited argument grabber. The auxiliary function does
+% a peek test before calling \cs{xparse_grab_arg:w}, so that the
+% optional nature of the argument works as expected.
+% \begin{macrocode}
+\cs_new:Npn \xparse_grab_D:w #1#2#3#4 \l_xparse_args_toks {
+ \xparse_grab_D_aux:NNnnNn #1 #2 {#3} {#4} \cs_set_nopar:Npn
+ { _ignore_spaces }
+}
+\cs_new:Npn \xparse_grab_D_long:w #1#2#3#4 \l_xparse_args_toks {
+ \xparse_grab_D_aux:NNnnNn #1 #2 {#3} {#4} \cs_set:Npn
+ { _ignore_spaces }
+}
+\cs_new:Npn \xparse_grab_D_trailing:w #1#2#3#4 \l_xparse_args_toks {
+ \xparse_grab_D_aux:NNnnNn #1 #2 {#3} {#4} \cs_set_nopar:Npn { }
+}
+\cs_new:Npn \xparse_grab_D_long_trailing:w #1#2#3#4
+ \l_xparse_args_toks {
+ \xparse_grab_D_aux:NNnnNn #1 #2 {#3} {#4} \cs_set:Npn { }
+}
+\cs_set:Nn \xparse_grab_D_aux:NNnnNn {
+ #5 \xparse_grab_arg:w #1 ##1 #2 {
+ \xparse_add_arg:n {##1}
+ #4 \l_xparse_args_toks
+ }
+ \use:c { peek_charcode #6 :NTF } #1 {
+ \xparse_grab_arg:w
+ }{
+ \xparse_add_arg:n {#3}
+ #4 \l_xparse_args_toks
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_grab_G:w}
+%\begin{macro}{\xparse_grab_G_long:w}
+%\begin{macro}{\xparse_grab_G_trailing:w}
+%\begin{macro}{\xparse_grab_G_long_trailing:w}
+%\begin{macro}[aux]{\xparse_grab_G_aux:nnNn}
+% Optional groups are checed by meaning, so that the same code will
+% work with, for example, Con\TeX{}t-like input.
+% \begin{macrocode}
+\cs_new:Npn \xparse_grab_G:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_G_aux:nnNn {#1} {#2} \cs_set_nopar:Npn { _ignore_spaces }
+}
+\cs_new:Npn \xparse_grab_G_long:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_G_aux:nnNn {#1} {#2} \cs_set:Npn { _ignore_spaces }
+}
+\cs_new:Npn \xparse_grab_G_trailing:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_G_aux:nnNn {#1} {#2} \cs_set_nopar:Npn { }
+}
+\cs_new:Npn \xparse_grab_G_long_trailing:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_G_aux:nnNn {#1} {#2} \cs_set:Npn { }
+}
+\cs_set:Nn \xparse_grab_G_aux:nnNn {
+ #3 \xparse_grab_arg:w ##1 {
+ \xparse_add_arg:n {##1}
+ #2 \l_xparse_args_toks
+ }
+ \use:c { peek_meaning #4 :NTF } \c_group_begin_token {
+ \xparse_grab_arg:w
+ }{
+ \xparse_add_arg:n {#1}
+ #2 \l_xparse_args_toks
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_grab_l:w}
+%\begin{macro}{\xparse_grab_l_long:w}
+%\begin{macro}[aux]{\xparse_grab_l_aux:nN}
+% Argument grabbers for mandatory \TeX\ arguments are pretty simple.
+% \begin{macrocode}
+\cs_new:Npn \xparse_grab_l:w #1 \l_xparse_args_toks {
+ \xparse_grab_l_aux:nN {#1} \cs_set_nopar:Npn
+}
+\cs_new:Npn \xparse_grab_l_long:w #1 \l_xparse_args_toks {
+ \xparse_grab_l_aux:nN {#1} \cs_set:Npn
+}
+\cs_new:Nn \xparse_grab_l_aux:nN {
+ #2 \xparse_grab_arg:w ##1## {
+ \xparse_add_arg:n \l_xparse_args_toks {##1}
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_grab_m:w}
+%\begin{macro}{\xparse_grab_m_long:w}
+% Collecting a single mandatory argument is quite easy.
+% \begin{macrocode}
+\cs_new:Npn \xparse_grab_m:w #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1 {
+ \xparse_add_arg:n {##1}
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:Npn \xparse_grab_m_long:w #1 \l_xparse_args_toks {
+ \cs_set:Npn \xparse_grab_arg:w ##1 {
+ \xparse_add_arg:n {##1}
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_grab_m_1:w}
+%\begin{macro}{\xparse_grab_m_2:w}
+%\begin{macro}{\xparse_grab_m_3:w}
+%\begin{macro}{\xparse_grab_m_4:w}
+%\begin{macro}{\xparse_grab_m_5:w}
+%\begin{macro}{\xparse_grab_m_6:w}
+%\begin{macro}{\xparse_grab_m_7:w}
+%\begin{macro}{\xparse_grab_m_8:w}
+% Grabbing 1--8 mandatory arguments. We don't need to worry about
+% nine arguments as this is only possible if everything is
+% mandatory. Each function has an auxiliary so that \cs{par} tokens
+% from other arguments still work.
+% \begin{macrocode}
+\cs_new:cpn { xparse_grab_m_1:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1 {
+ \toks_put_right:Nn \l_xparse_args_toks { {##1} }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:cpn { xparse_grab_m_2:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1##2 {
+ \toks_put_right:Nn \l_xparse_args_toks { {##1} {##2} }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:cpn { xparse_grab_m_3:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1##2##3 {
+ \toks_put_right:Nn \l_xparse_args_toks { {##1} {##2} {##3} }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:cpn { xparse_grab_m_4:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1##2##3##4 {
+ \toks_put_right:Nn \l_xparse_args_toks { {##1} {##2} {##3} {##4} }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:cpn { xparse_grab_m_5:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1##2##3##4##5 {
+ \toks_put_right:Nn \l_xparse_args_toks {
+ {##1} {##2} {##3} {##4} {##5}
+ }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:cpn { xparse_grab_m_6:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1##2##3##4##5##6 {
+ \toks_put_right:Nn \l_xparse_args_toks {
+ {##1} {##2} {##3} {##4} {##5} {##6}
+ }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:cpn { xparse_grab_m_7:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1##2##3##4##5##6##7 {
+ \toks_put_right:Nn \l_xparse_args_toks {
+ {##1} {##2} {##3} {##4} {##5} {##6} {##7}
+ }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+\cs_new:cpn { xparse_grab_m_8:w } #1 \l_xparse_args_toks {
+ \cs_set_nopar:Npn \xparse_grab_arg:w ##1##2##3##4##5##6##7##8 {
+ \toks_put_right:Nn \l_xparse_args_toks {
+ {##1} {##2} {##3} {##4} {##5} {##6} {##7} {##8}
+ }
+ #1 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_grab_t:w}
+%\begin{macro}{\xparse_grab_t_long:w}
+%\begin{macro}{\xparse_grab_t_trailing:w}
+%\begin{macro}{\xparse_grab_t_long_trailing:w}
+%\begin{macro}[aux]{\xparse_grab_t_aux:NnNn}
+% Dealing with a token is quite easy. Check the match, remove the
+% token if needed and add a flag to the output.
+% \begin{macrocode}
+\cs_new:Npn \xparse_grab_t:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_t_aux:NnNn #1 {#2} \cs_set_nopar:Npn { _ignore_spaces }
+}
+\cs_new:Npn \xparse_grab_t_long:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_t_aux:NnNn #1 {#2} \cs_set:Npn { _ignore_spaces }
+}
+\cs_new:Npn \xparse_grab_t_trailing:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_t_aux:NnNn #1 {#2} \cs_set_nopar:Npn { }
+}
+\cs_new:Npn \xparse_grab_t_long_trailing:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_t_aux:NnNn #1 {#2} \cs_set:Npn { }
+}
+\cs_new:Nn \xparse_grab_t_aux:NnNn {
+ #3 \xparse_grab_arg:w {
+ \use:c { peek_charcode_remove #4 :NTF } #1 {
+ \xparse_add_arg:n { \BooleanTrue }
+ #2 \l_xparse_args_toks
+ }{
+ \xparse_add_arg:n { \BooleanFalse }
+ #2 \l_xparse_args_toks
+ }
+ }
+ \xparse_grab_arg:w
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_grab_u:w}
+%\begin{macro}{\xparse_grab_u_long:w}
+%\begin{macro}[aux]{\xparse_grab_u_aux:NnN}
+% Grabbing up to a list of tokens is quite easy: define the grabber,
+% and then collect.
+% \begin{macrocode}
+\cs_new:Npn \xparse_grab_u:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_u_aux:NnN {#1} {#2} \cs_set_nopar:Npn
+}
+\cs_new:Npn \xparse_grab_u_long:w #1#2 \l_xparse_args_toks {
+ \xparse_grab_u_aux:NnN {#1} {#2} \cs_set:Npn
+}
+\cs_new:Nn \xparse_grab_u_aux:NnN {
+ #3 \xparse_grab_arg:w ##1 #1 {
+ \xparse_add_arg:n {##1}
+ #2 \l_xparse_args_toks
+ }
+ \xparse_grab_arg:w
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\subsection{Argument processors}
+%
+%\begin{macro}{\xparse_process_to_str:n}
+% A basic argument processor: as much an example as anything else.
+% \begin{macrocode}
+\cs_new:Nn \xparse_process_to_str:n {
+ \toks_set:Nx \l_xparse_arg_toks {
+ \tl_to_str:n {#1}
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_process_comma_split:n}
+%\begin{macro}[aux]{\xparse_process_comma_split_aux:w}
+% Turns a co-ordinate pair into two separate values.
+% \begin{macrocode}
+\cs_new:Nn \xparse_process_comma_split:n {
+ \tl_if_in:nnTF {#1} { , } {
+ \xparse_process_comma_split_aux:w #1 \q_stop
+ }{
+ \toks_set:Nn \l_xparse_arg_toks { {#1} { \NoValue } }
+ }
+}
+\cs_new:Npn \xparse_process_comma_split_aux:w #1 , #2 \q_stop {
+ \toks_set:Nn \l_xparse_arg_toks { {#1} {#2} }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+%\subsection{Creating expandable functions}
+%
+% The trick here is to pass each grabbed argument along a chain of
+% auxiliary functions. Each one ultimately calls the next in the chain,
+% so that all of the arguments are passed along delimited using
+% \cs{q_xparse_stop}. At the end of the chain, the marker is removed
+% so that the user-supplied code can be passed the correct number
+% of arguments. All of this is done by expansion!
+%
+%\begin{macro}{\xparse_exp_add_type_d:w}
+% As in the standard case, the trick here is to slot in the default
+% and treat as type \texttt{D}.
+% \begin{macrocode}
+\cs_new:Npn \xparse_exp_add_type_d:w #1#2 {
+ \xparse_exp_add_type_D:w #1 #2 { \NoValue }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_add_type_D:w}
+% The most complex argument to grab in an expandable manner is the
+% general delimited one. First, a shortcut is set up in
+% \cs{l_xparse_tmpa_tl} for the name of the current grabber function.
+% This is then created to grab one argument and test if it is equal
+% to the opening delimiter. If the test fails, the code adds the default
+% value and closing delimiter before `recycling' the argument. In either
+% case, the second auxiliary function is called. It finds the closing
+% delimiter and so the optional argument (if any). The function then
+% calls the next one in the chain, passing along the argument(s)
+% grabbed thus-far using \cs{q_xparse_stop} as a marker.
+% \begin{macrocode}
+\cs_new:Npn \xparse_exp_add_type_D:w #1#2#3 {
+ \tl_set:Nx \l_xparse_tmpa_tl {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \int_use:N \l_xparse_total_args_int
+ }
+ \xparse_exp_set:cpx { \l_xparse_tmpa_tl } ##1 \q_xparse_stop ##2 {
+ \exp_not:N \tl_if_head_eq_charcode:nNTF {##2} #1 {
+ \exp_not:c { \l_xparse_tmpa_tl aux }
+ ##1 \exp_not:N \q_xparse_stop
+ }{
+ \exp_not:c { \l_xparse_tmpa_tl aux }
+ ##1 \exp_not:N \q_xparse_stop #3 #2 {##2}
+ }
+ }
+ \xparse_exp_set:cpx { \l_xparse_tmpa_tl aux}
+ ##1 \q_xparse_stop ##2 #2 {
+ \exp_not:c {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \intexpr_eval:n { \l_xparse_total_args_int + 1 }
+ } ##1 {##2} \exp_not:N \q_xparse_stop
+ }
+ \xparse_exp_prepare_function:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_add_type_l:w}
+%\begin{macro}{\xparse_exp_add_type_m:w}
+% Gathering \texttt{l} and \texttt{m} arguments is almost the same.
+% The grabber for the current argument is created to simply get the
+% necessary argument and pass it along with any others through to the
+% next function in the chain.
+% \begin{macrocode}
+\cs_new_nopar:Npn \xparse_exp_add_type_l:w {
+ \xparse_exp_set:cpx {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \int_use:N \l_xparse_total_args_int
+ } ##1 \q_xparse_stop ##2## {
+ \exp_not:c {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \intexpr_eval:n { \l_xparse_total_args_int + 1 }
+ }
+ ##1 {##2} \exp_not:N \q_xparse_stop
+ }
+ \xparse_exp_prepare_function:N
+}
+\cs_new_nopar:Npn \xparse_exp_add_type_m:w {
+ \int_incr:N \l_xparse_m_args_int
+ \xparse_exp_set:cpx {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \int_use:N \l_xparse_total_args_int
+ } ##1 \q_xparse_stop ##2 {
+ \exp_not:c {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \intexpr_eval:n { \l_xparse_total_args_int + 1 }
+ }
+ ##1 {##2} \exp_not:N \q_xparse_stop
+ }
+ \xparse_exp_prepare_function:N
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_add_type_t:w}
+% Looking for a single token is a simpler version of the \texttt{D}
+% code. The same idea of picking up one argument is used, but there is
+% no need for a second function as there is no closing token to find. So
+% either \cs{BooleanTrue} or \cs{BooleanFalse} are added to the list of
+% arguments. In the later case, the grabber argument must be `recycled'.
+% \begin{macrocode}
+\cs_new:Npn \xparse_exp_add_type_t:w #1 {
+ \tl_set:Nx \l_xparse_tmpa_tl {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \intexpr_eval:n { \l_xparse_total_args_int + 1 }
+ }
+ \xparse_exp_set:cpx {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \int_use:N \l_xparse_total_args_int
+ } ##1 \q_xparse_stop ##2 {
+ \exp_not:N \tl_if_head_eq_charcode:nNTF {##2} #1 {
+ \exp_not:c { \l_xparse_tmpa_tl }
+ ##1 \exp_not:n { { \BooleanTrue } \q_xparse_stop }
+ }{
+ \exp_not:c { \l_xparse_tmpa_tl }
+ ##1 \exp_not:n { { \BooleanFalse } \q_xparse_stop {##2} }
+ }
+ }
+ \xparse_exp_prepare_function:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_add_type_u:w}
+% Setting up for a \texttt{u} argument is a case of defining the
+% grabber for the current argument in a delimited fashion. The rest of
+% the process is as the other grabbers: add to the chain and call the
+% next function.
+% \begin{macrocode}
+\cs_new:Npn \xparse_exp_add_type_u:w #1 {
+ \xparse_exp_set:cpx {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \int_use:N \l_xparse_total_args_int
+ } ##1 \q_xparse_stop ##2 #1 {
+ \exp_not:c {
+ \exp_after:wN \token_to_str:N \l_xparse_function_tl
+ \intexpr_eval:n { \l_xparse_total_args_int + 1 }
+ }
+ ##1 {##2} \exp_not:N \q_xparse_stop
+ }
+ \xparse_exp_prepare_function:N
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_check_and_add:N}
+% Virtually identical to the normal version, except calling the
+% expandable \texttt{add} functions rather than the standard versions.
+% \begin{macrocode}
+\cs_new_nopar:Nn \xparse_exp_check_and_add:N {
+ \cs_if_free:cTF { xparse_exp_add_type_ #1 :w } {
+ \msg_error:nnx { xparse } { unknown-argument-type } {#1}
+ \tl_set:Nn \l_xparse_last_arg_tl { m }
+ \xparse_exp_add_type_m:w
+ }{
+ \tl_set:Nn \l_xparse_last_arg_tl {#1}
+ \use:c { xparse_exp_add_type_ #1 :w }
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_declare_cmd:Nnn}
+%\begin{macro}[aux]{\xparse_exp_declare_cmd_all_m:Nn}
+%\begin{macro}[aux]{\xparse_exp_declare_cmd_mixed:Nn}
+%\begin{macro}[aux]{\xparse_exp_declare_cmd_mixed_aux:Nn}
+% The overall scheme here is very different from the standard method.
+% For each argument, an internal fucntion is created to grab an argument
+% and pass along prevous ones. Each `daisy chains' to call the next
+% one in the sequence. Thus at the end of the chain, an extra `argument'
+% function is included to unwind the chain and pass data to the the
+% internal function containing the actual code. If all of the arguments
+% are type \texttt{m}, then the same tick is used as in the standard
+% version. The \texttt{x} in the lead-off and mop-up functions makes
+% sure that the braces around the first argument are not lost.
+% \begin{macrocode}
+\cs_new:Nn \xparse_exp_declare_cmd:Nnn {
+ \tl_set:Nn \l_xparse_function_tl {#1}
+ \xparse_exp_prepare_function:n {#2}
+ \intexpr_compare:nTF {
+ \l_xparse_total_args_int = \l_xparse_m_args_int
+ } {
+ \xparse_exp_declare_cmd_all_m:Nn #1 {#3}
+ }{
+ \xparse_exp_declare_cmd_mixed:Nn #1 {#3}
+ }
+}
+\cs_new:Nn \xparse_exp_declare_cmd_all_m:Nn {
+ \bool_if:NTF \l_xparse_long_bool {
+ \cs_generate_from_arg_count:NNnn
+ #1 \cs_set:Npn \l_xparse_total_args_int {#2}
+ }{
+ \cs_generate_from_arg_count:NNnn
+ #1 \cs_set_nopar:Npn \l_xparse_total_args_int {#2}
+ }
+}
+\cs_new:Nn \xparse_exp_declare_cmd_mixed:Nn {
+ \exp_args:NnV \tl_if_in:nnTF { l m u } \l_xparse_last_arg_tl {
+ \xparse_exp_declare_cmd_mixed_aux:Nn #1 {#2}
+ }{
+ \msg_error:nn { xparse } { expandable-ending-optional }
+ }
+}
+\cs_new:Nn \xparse_exp_declare_cmd_mixed_aux:Nn {
+ \cs_set_nopar:Npx #1 {
+ \exp_not:c { \token_to_str:N #1 1 } x \exp_not:N \q_xparse_stop
+ }
+ \cs_set_nopar:cpx {
+ \token_to_str:N #1 \intexpr_eval:n { \l_xparse_total_args_int + 1 }
+ } x ##1 \q_xparse_stop {
+ \exp_not:c { \token_to_str:N #1 } ##1
+ }
+ \cs_generate_from_arg_count:cNnn
+ { \token_to_str:N #1 } \cs_set:Npn \l_xparse_total_args_int {#2}
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_prepare_function:n}
+%\begin{macro}[aux]{\xparse_exp_prepare_function_aux:n}
+% A couple of early validation tests. Processors are forbidden, as are
+% \texttt{g}, \texttt{l} and \texttt{u} arguments (the later more for
+% ease than any technical reason).
+% \begin{macrocode}
+\cs_new:Nn \xparse_exp_prepare_function:n {
+ \bool_set_false:N \l_xparse_error_bool
+ \tl_if_in:nnT {#1} { > } {
+ \msg_error:nnx { xparse } { processor-in-expandable } {#1}
+ \bool_set_true:N \l_xparse_error_bool
+ }
+ \tl_if_in:nnT {#1} { g } {
+ \msg_error:nnx { xparse } { grouped-in-expandable } {#1}
+ \bool_set_true:N \l_xparse_error_bool
+ }
+ \tl_if_in:nnT {#1} { G } {
+ \msg_error:nnx { xparse } { grouped-in-expandable } {#1}
+ \bool_set_true:N \l_xparse_error_bool
+ }
+ \bool_if:NF \l_xparse_error_bool {
+ \xparse_exp_prepare_function_aux:n {#1}
+ }
+}
+\cs_new:Nn \xparse_exp_prepare_function_aux:n {
+ \cs_set_eq:NN \xparse_prepare_next:w \xparse_exp_prepare_function:N
+ \cs_set_eq:NN \xparse_exp_set:cpx \cs_set_nopar:cpx
+ \bool_set_false:N \l_xparse_long_bool
+ \int_zero:N \l_xparse_m_args_int
+ \int_zero:N \l_xparse_total_args_int
+ \tl_if_in:nnT {#1} { + } {
+ \bool_set_true:N \l_xparse_long_bool
+ \cs_set_eq:NN \xparse_exp_set:cpx \cs_set:cpx
+ }
+ \xparse_exp_prepare_function:N #1 \q_nil
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_prepare_function:N}
+%\begin{macro}[aux]{\xparse_exp_prepare_function_long:N}
+%\begin{macro}[aux]{\xparse_exp_prepare_function_short:N}
+% Preparing functions is a case of
+% \begin{macrocode}
+\cs_new:Nn \xparse_exp_prepare_function:N {
+ \bool_if:NTF \l_xparse_long_bool {
+ \xparse_exp_prepare_function_long:N #1
+ }{
+ \xparse_exp_prepare_function_short:N #1
+ }
+}
+\cs_new:Nn \xparse_exp_prepare_function_long:N {
+ \quark_if_nil:NF #1 {
+ \tl_if_eq:nnTF {#1} { + } {
+ \xparse_exp_prepare_function_short:N
+ }{
+ \msg_error:nn { xparse } { inconsistent-long }
+ \xparse_exp_prepare_function_short:N #1
+ }
+
+ }
+}
+\cs_new:Nn \xparse_exp_prepare_function_short:N {
+ \quark_if_nil:NF #1 {
+ \prop_if_in:NnTF \c_xparse_shorthands_prop {#1} {
+ \prop_get:NnN \c_xparse_shorthands_prop {#1} \l_xparse_tmp_tl
+ \bool_if:NT \l_xparse_long_bool {
+ \tl_put_left:Nn \l_xparse_tmp_tl { + }
+ }
+ \exp_last_unbraced:NV \xparse_exp_prepare_function:N
+ \l_xparse_tmp_tl
+ }{
+ \int_incr:N \l_xparse_total_args_int
+ \xparse_exp_check_and_add:N #1
+ }
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\xparse_exp_set:cpx}
+% A shortcut to save constantly re-testing \cs{l_xparse_long_bool}.
+% \begin{macrocode}
+\cs_new_eq:NN \xparse_exp_set:cpx \cs_set_nopar:cpx
+% \end{macrocode}
+%\end{macro}
+%
+%\subsection{Messages}
+%
+% Some error messages.
+% \begin{macrocode}
+\msg_new:nnnn { xparse } { command-already-defined } {%
+ Command name `\token_to_str:N #1' already defined!%
+}{%
+ You have used \token_to_str:N \NewDocumentCommand\\%
+ with a command that already has a definition.\\%
+ Perhaps you meant \token_to_str:N \RenewDocumentCommand.%
+}
+\msg_new:nnnn { xparse } { command-not-yet-defined } {%
+ Command `\token_to_str:N #1' not yet defined!%
+}{%
+ You have used \token_to_str:N \RenewDocumentCommand\\%
+ with a command that was never defined.\\%
+ Perhaps you meant \token_to_str:N \NewDocumentCommand.%
+}
+\msg_new:nnn { xparse } { environment-already-defined } {%
+ Environment `#1' already defined!%
+}
+\msg_new:nnn { xparse } { environment-not-yet-defined } {%
+ Environment `#1' not yet defined!%
+}
+\msg_new:nnnn { xparse } { expandable-ending-optional } {%
+ Expandable command signature ends in optional argument.%
+}{%
+ Expandable functions must have a final mandatory argument.%
+}
+\msg_new:nnnn { xparse } { grouped-in-expandable } {%
+ Optional grouped arguments cannot be used with expandable functions.%
+}{%
+ Argument specification `#1' contains an optional grouped argument:\\%
+ this is only supported for standard robust functions.%
+}
+\msg_new:nnnn { xparse } { inconsistent-long } {%
+ Inconsistent long arguments.%
+}{%
+ Expandable commands must have all arguments long if any at all.%
+}
+\msg_new:nnnn { xparse } { processor-in-expandable } {%
+ Argument processors cannot be used with expandable functions.%
+}{%
+ Argument specification `#1' contains a processor function:\\%
+ this is only supported for standard robust functions.%
+}
+\msg_new:nnn { xparse } { unknown-argument-type } {%
+ Unknown argument type `#1' replaced by `m'. Fingers crossed ...%
+}
+% \end{macrocode}
+%
+%\subsection{User functions}
+%
+% The user functions are more or less just the internal functions
+% renamed.
+%
+%\begin{macro}{\BooleanFalse}
+%\begin{macro}{\BooleanTrue}
+% Design-space names for the Boolean values.
+% \begin{macrocode}
+\cs_new_eq:NN \BooleanFalse \c_false_bool
+\cs_new_eq:NN \BooleanTrue \c_true_bool
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\DeclareDocumentCommand}
+%\begin{macro}{\NewDocumentCommand}
+%\begin{macro}{\RenewDocumentCommand}
+%\begin{macro}{\ProvideDocumentCommand}
+% The user macros are pretty simple wrappers around the internal ones.
+% \begin{macrocode}
+\xparse_declare_cmd:Nnn \DeclareDocumentCommand { +m +m +m } {
+ \xparse_declare_cmd:Nnn #1 {#2} {#3}
+}
+\DeclareDocumentCommand \NewDocumentCommand { +m +m +m } {
+ \cs_if_exist:NTF #1 {
+ \msg_error:nnx { xparse } { command-already-defined } {#1}
+ }{
+ \xparse_declare_cmd:Nnn #1 {#2} {#3}
+ }
+}
+\NewDocumentCommand \RenewDocumentCommand { +m +m +m } {
+ \cs_if_exist:NTF #1 {
+ \xparse_declare_cmd:Nnn #1 {#2} {#3}
+ }{
+ \msg_error:nnx { xparse } { command-not-yet-defined } {#1}
+ }
+}
+\NewDocumentCommand \ProvideDocumentCommand { +m +m +m } {
+ \cs_if_exist:NF #1 {
+ \xparse_declare_cmd:Nnn #1 {#2} {#3}
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\DeclareDocumentCommandImplementation}
+%\begin{macro}{\DeclareDocumentCommandInterface}
+% The separate implementation/interface system is again pretty simple
+% to create at the outer layer.
+% \begin{macrocode}
+\NewDocumentCommand \DeclareDocumentCommandImplementation { m m +m } {
+ \xparse_declare_cmd_implementation:nNn {#1} #2 {#3}
+}
+\NewDocumentCommand \DeclareDocumentCommandInterface { m m +m } {
+ \xparse_declare_cmd_interface:Nnn #1 {#2} {#3}
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\DeclareDocumentEnvironment}
+%\begin{macro}{\NewDocumentEnvironment}
+%\begin{macro}{\RenewDocumentEnvironment}
+%\begin{macro}{\ProvideDocumentEnvironment}
+% Very similar for environments.
+% \begin{macrocode}
+\NewDocumentCommand \DeclareDocumentEnvironment { m +m +m +m } {
+ \xparse_declare_env:nnnn {#1} {#2} {#3} {#4}
+}
+\NewDocumentCommand \NewDocumentEnvironment { m +m +m +m } {
+ \cs_if_exist:cTF { environment_begin_ #1 :w } {
+ \msg_error:nnx { xparse } { environment-already-defined } {#1}
+ }{
+ \xparse_declare_env:nnnn {#1} {#2} {#3} {#4}
+ }
+}
+\NewDocumentCommand \RenewDocumentEnvironment { m +m +m +m } {
+ \cs_if_exist:cTF { environment_begin_ #1 :w } {
+ \xparse_declare_env:nnnn {#1} {#2} {#3} {#4}
+ }{
+ \msg_error:nnx { xparse } { environment-not-yet-defined } {#1}
+ }
+}
+\NewDocumentCommand \ProvideDocumentEnvironment { m +m +m +m } {
+ \cs_if_exist:cF { environment_begin_ #1 :w } {
+ \xparse_declare_env:nnnn {#1} {#2} {#3} {#4}
+ }
+}
+% \end{macrocode}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%\end{macro}
+%
+%\begin{macro}{\DeclareExpandableDocumentCommand}
+% The expanable version of the basic function is essentially the same.
+% \begin{macrocode}
+\NewDocumentCommand \DeclareExpandableDocumentCommand { +m +m +m } {
+ \xparse_exp_declare_cmd:Nnn #1 {#2} {#3}
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}[TF]{\IfBoolean}
+% The logical \meta{true} and \meta{false} statements are just the
+% normal \cs{c_true_bool} and \cs{c_false_bool}, so testing for them is
+% done with the \cs{bool_if:NTF} functions from \textsf{l3prg}.
+% \begin{macrocode}
+\cs_new_eq:NN \IfBooleanTF \bool_if:NTF
+\cs_new_eq:NN \IfBooleanT \bool_if:NT
+\cs_new_eq:NN \IfBooleanF \bool_if:NF
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}[TF]{\IfNoValue}
+% Simple re-naming.
+% \begin{macrocode}
+\cs_new_eq:NN \IfNoValueF \xparse_if_no_value:nF
+\cs_new_eq:NN \IfNoValueT \xparse_if_no_value:nT
+\cs_new_eq:NN \IfNoValueTF \xparse_if_no_value:nTF
+% \end{macrocode}
+%\end{macro}
+%\begin{macro}[TF]{\IfValue}
+% Inverted logic.
+% \begin{macrocode}
+\cs_set:Npn \IfValueF { \xparse_if_no_value:nT }
+\cs_set:Npn \IfValueT { \xparse_if_no_value:nF }
+\cs_set:Npn \IfValueTF #1#2#3 {
+ \xparse_if_no_value:nTF {#1} {#3} {#2}
+}
+% \end{macrocode}
+%\end{macro}
+%
+%\begin{macro}{\NoValue}
+% The marker for no value being give: this can be typeset safely.
+% This is coded by hand as making it \cs{protected} ensures that it
+% will not turn into anything else by accident.
+% \begin{macrocode}
+\NewDocumentCommand \NoValue { } { -NoValue- }
+% \end{macrocode}
+%\end{macro}
+%
+% \begin{macrocode}
+%</initex|package>
+% \end{macrocode}
+%
+% \end{implementation}
+%
+% \PrintIndex