summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/source/latex/xpackages/xbase/xparse.dtx
diff options
context:
space:
mode:
Diffstat (limited to 'Master/texmf-dist/source/latex/xpackages/xbase/xparse.dtx')
-rw-r--r--Master/texmf-dist/source/latex/xpackages/xbase/xparse.dtx2443
1 files changed, 2443 insertions, 0 deletions
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