%% 
%% \iffalse ^^A we skip the debug setting
\IfFileExists{\string~/bin/gen_and_xela}{\errorcontextlines=1000 }{}
%% \fi
%% ^^A $Id: TheUltimateMaster.gmd,v 0.352 2011/10/12 15:19:42 natror Exp natror $
%% This is file “gmcommand.sty” generated with the DocStrip utility.
%% 
%%
%% The original source files were:
%%
%% gmutils/gmutils.gmd  (with options: `command')
%%
%% 
%% Copyright ©  
%% by Grzegorz ‘Natror’ Murzynowski
%% natror (at) gmail (dot) com
%% 
%% This program is subject to the LaTeX Project Public License.
%% See http://www.ctan.org/tex-archive/help/Catalogue/licenses.lppl.html
%% for the details of that license.
%%
%% LPPL status: "author-maintained".
%%
%% 
%% 
%% For documentation please refer to the file(s)
%% gmutils.{gmd,pdf}.
%% 
%% 
\NeedsTeXFormat{LaTeX2e}
\ProvidesPackage{gmcommand}
    [2011/10/12 v0.996 definition of \string \DeclareCommand \string &al. based on the ancient xparse (pre-expl3) (GM)]


%%
%%
%%     ^^A\typeout{\unexpanded{#4}}%%

\RequirePackage{gmbase} % we require the low-level macros.

\unless\ifcsname ifgmu@quiet\endcsname
\Name\newif {ifgmu@quiet}% % it has to be at least (at highest) in
 % \CH{2010/09/06 v0.993 moved here from
                    % % \pk{gmutils.sty} (a bug fix)}
\fi


\unless\ifdefined\@temptokenb
\newtoks\@temptokenb
\fi

\newif\if@dc@alllong@ % for an option of all arguments long (it's
                      % stronger than |GroteLang| defined later (the
                      % latter is |\let| it).
\newif\if@dc@quiet@ % for suppressing the message of using  of

\newif\ifDCMessages % a~global switch to suppress the message about

\newtoks\@dc@arguments % the register for storing parsed
                       % |\\command {#1}›…{⁄<n>}|.

\newcount\c@dc@catchernum
\newcount\c@dc@argnum

\newif\if@dc@ignore@
\newif\if@dc@GroteNegere@ % for “gross” ignoring
\newif\if@dc@GroteLang@ % for “gross” longness

\newif\if@dc@long@

\newif\if@dc@BareSpace@


\def\@dc@long@letter{%
\if@dc@long@ P\fi
}

\newif\if@dc@xadefault

\def\@nx@xa{\@nx\@xa}
\def\@xa@nx{\@xa\@nx}
\def\@xa@xa{\@xa\@xa}

\newif\if@dc@xadefault@i@
\newif\if@dc@xadefault@ii@
\newif\if@dc@xaeacher@

\def\@dc@falsify@xadefaults{%
  \@dc@xadefaultfalse
  \@dc@xadefault@i@false
  \@dc@xadefault@ii@false
}

\lpdef\DeclareCommand#1#2#3{% ^^B It's the draft version just
  % ^^B~to declare the true one, which is  defined in line
  % \ref{DC:final}.
  %
  % \begin{enumargs}
  % \item command to be defined,
  % \item arguments specification,
  % \item definition body.
  % \end{enumargs}
  % \chgs[\DeclareCommand]{2008/12/05 v0.98 added the \env{S}/\env{T}
  %   spec parsing, the
  %   \env{s} spec parsing rewritten to be a~shorthand for
  %   \env{S\{*\}}, unused code removed}
  % \chgs{2010/04/15 v0.993 implemented the \cmd\SameAs feature}
  %
  %
  %
\@dc@alllong@true
  \@dc@ResetParseAuxilia
  %
  \@dc@ParseNextSpecifier #2%
  \@dc@buckstopshere% it's the sentinel of parsing. Doesn't have to be
  % defined since the test performs a strings comparison.
  \protected\edef#1{%
    \@nx\@dc@    {\the\toks@}%
    \@xanxcs{\@dc@InnerName{#1}}%
    \@nx #1%
  }%
  \edef\gmu@DeclareCommand@resa{%
    \long\def\@xanxcs{\@dc@InnerName{#1}}%
    \@xau\@dc@innerhashes{%
      \unexpanded{#3}}%
  }% of resa
  \gmu@DeclareCommand@resa
}% of the ‘draft’ |\DeclareCommand|.

\long\def\@dc@
  #1%  the argument catchers in a~pair of braces (their arguments
  %   may contain \incmd\par\ so the macro is long).
  #2% |\\thecommand\|
  #3% |\thecommand|
  {%
  \ifx\protect\@typeset@protect
    \@xa\@firstofone
  \else
    \protect#3\@xa\@gobble
  \fi
  {\@dc@arguments{#2}#1\the\@dc@arguments}%
}

\newtoks \@dc@ParsedSpecs

\def\@dc@ResetParseAuxilia{%
  %
  \@dc@ParsedSpecs={}%
  %
  \c@dc@catchernum\z@ % the count of catchers
  \c@dc@argnum\z@ % the count of arguments (inner arity) (it may be
                 % smaller than the above if we ignore some arguments)
  %
  \toks@{}% in this register we will store  the created sequence of
  % argument catchers.
  %
  % And for the |M⁄m| specifiers:
  \@dc@Mmode@false
  %
  \emptify\@dc@innerhashes % in this macro we will store the sequence of
                     % \inverb|#1#2…|.
                     %
  \@dc@GroteNegere@false
  \let\if@dc@GroteLang@\if@dc@alllong@
}

\newif \if@dc@Mmode@
\def\@dc@Ms@num {\z@}%

\def\@dc@Ms@init{%
  \@dc@Mmode@true
  \def\@dc@Ms@num {\z@}%
  \edef\@dc@Ms@initial@listate{%
    \@dc@Ms@listate
  }% of edef
}

\def\@dc@Ms@listate{%
  \boolstobin{{@dc@long@}{@dc@ignore@}}%
}

\def\@dc@Ms@shipout {%
  \gmu@if {num} {\@dc@Ms@num>\z@}%
  {\@xa\dc@addtoParsed@\@xa{\@dc@Ms@num}%
    \def\@dc@Ms@num{\z@}%
    \@dc@Mmode@false
   }%
   {}%
}

\def\@dc@ResetStepAuxilia {%
  % We set the local ignorance switch to its “gross” value
  \let\if@dc@ignore@ =\if@dc@GroteNegere@
  \let\if@dc@long@ = \if@dc@GroteLang@
  % and reset the expandaftering switches
  \@dc@falsify@xadefaults
  \@dc@BareSpace@false
}

\def\@dc@argtypes{%
  =\gobblespace \loop \lostwax \SameAs \Scope
  AaBbCcDdGgKkMmOo%
  QqSs*TtUuWw%
  \drs
}

\def\@dc@drses{\drs} % decimal respecting space

\@ifXeTeX
{\addtomacro\@dc@argtypes{ďĎŤťǓǔÔô}%
  \addtomacro\@dc@drses{ďĎ}%
}
{}

\def\@dc@ParseSpecifier #1{% The main inner macro parsing argument
  \gmu@CASE {stribs}{{#1}\@dc@buckstopshere}%
  {%
  \@dc@Ms@shipout
    \edef\@dc@innerhashes {%
      \gmu@hashes 1{\numexpr\c@dc@argnum +\@ne}%
    }%
  }%
  \gmu@CASE {stribs}{{#1}>}%
  {%
    \grab@prefix }%
  \@XA{%
    \gmu@CASEsbnone{#1}}\@xa{%
    \@dc@argtypes
  }%
  {\IgnInfo{gmcommand}{while parsing arg specifiers}{#1}%
    \@dc@ParseNextSpecifier }%
  \gmu@CASE {stribs}{{#1}\SameAs}%
  {\@dc@SameAs}%
  \gmu@ifsbnone {#1}{Mm}%
  {\@dc@Ms@shipout }%
  {}%
  \gmu@if {@dc@Mmode@}{}%
  {}%
  {%
    \gmu@ifsbany{#1}{=\gobblespace}{\@dc@ignore@true}{}%
    \gmu@ifsw {@dc@BareSpace@}%
    {\@dc@addtoparsed@BareSpace }
    {}%
    %
    %
    \gmu@ifsw {@dc@long@}%
    {\@dc@addtospecs@bare{>P}}
    {}%
    %
    \gmu@ifsw {@dc@ignore@}%
    {\@dc@addtoparsed@Ignore   }%
    {}%
    %
    \@dc@addtospecs@bare {#1}%
    %
    \@xa\addtotoks\@xa\toks@\@xa{%
      \csname ArgumentCatcher@\@dc@long@letter
      \strip@bslash{#1}%
      \endcsname
    }% of toks' text.
    \advance\c@dc@catchernum\@ne
  }% of if not |M|-mode
  \gmu@notif {@dc@ignore@}{}%
  {\@dc@addinnerhash }% \label{@dc@addinnerhash}
  {}% (empty “not-else” branch of ignoring)
  \gmu@CASEsbany {#1}{Mm}%
  {\@dc@process@ms}%
  \gmu@CASEsbany {#1}{Kk}%
  {\@dc@define@K}%
  \gmu@CASEsbany {#1}{\gobblespace}%
  {\@dc@ParseNextSpecifier}%
  \gmu@CASEsbany{#1}{=\Scope AaBbCcDdOoSs*}%
  {\grab@optparam{#1}}%
  \@XA{\gmu@CASEsbany{#1}}\@xa{\@dc@drses}%
  {\grab@optparam{#1}}%
  \gmu@CASEsbany{#1}{UuǓǔWw\lostwax}%
  {\@dc@grab@Loop #1}% putting the specifier's letter as |#1| for the
  % grabber suppresses adding it to the parsed specifiers' list.
  \gmu@lastCASE
  {%
    \grab@twoparams{#1}}%
  \gmu@ESAC
  %
}% of  |\@dc@ParseSpecifier|

\def\@dc@addtoparsed@Ignore{%
  \addtotoks\toks@{\@dc@ignorearg}%
  \@dc@addtospecs@bare{>i}%
}

\def\@dc@addinnerhash{%
  \advance\c@dc@argnum\@ne
}

\def\@dc@addtoparsed@BareSpace{%
  \addtotoks\toks@{\@dc@BareSpaceArg }%
  \@dc@addtospecs@bare{>\BareSpace }%
}

\def\@dc@process@ms{%
  \gmu@if {@dc@Mmode@}{}%
  {\gmu@if {num}{\@dc@Ms@initial@listate=\@dc@Ms@listate}%
    {\@dc@process@ms@grabnum }% of if the state has'nt been changed
    {\@dc@Ms@shipout
 % Remember however that we've increased number of arguments so now we
 % set it back:
       \advance\c@dc@argnum\m@ne
      \@dc@ParseSpecifier m%
    }% of if the state has been changed
  }% of if |M|-mode
  {\@dc@Ms@init
  \@dc@process@ms@grabnum
  }% of not if |M|-mode.
}% of \@dc@process@ms

\def \@dc@process@ms@grabnum {%
  \@ifnextanyIS {\bgroup \@ne \tw@ \thr@@ 123456789}%
  {%
    \@dc@process@ms@fin}%
  {%
    \@dc@process@ms@fin \@ne}%
}

\def \@dc@process@ms@fin #1{%
  \edef\@dc@processms@hash {\the\numexpr#1}%
  \edef\@dc@processms@left {\the\numexpr 9-\c@dc@argnum+\@ne}%
  %
  \gmu@AND {%
    {num} {\@dc@processms@hash >\z@}
    {num} {\@dc@processms@hash <\numexpr
      \@dc@processms@left+1 \relax }%
  }%
  {\stepnummacro \@dc@Ms@num \@dc@processms@hash
    \edef\@dc@hashgoal {%
      \the\numexpr\c@dc@argnum +%
      \@dc@processms@hash-1}% minus 1 because one
    \@whilenum \c@dc@argnum<\@dc@hashgoal \do{%
      \@dc@addinnerhash
    }%
    %
    \@dc@ParseNextSpecifier
  }% of if all conds.\ satisfied
  {% some of the conds.\ not satisfied
    \PackageError{gmcommand}{%
      The argument to the M or m specifier, if any, has to be ^^J%
      a number between 1 and \@dc@processms@left ^^J%
      (there is/are \the\c@dc@argnum\space arg(s) declared
      already).^^J%
      I ignore this m/M.}%
    {}%
    \gmu@passbraced  \@dc@ParseNextSpecifier {#1}%
  }%
}% of |\@dc@process@ms|

\def\@dc@ParseNextSpecifier{%
  \@dc@ResetStepAuxilia
  \@dc@ParseSpecifier
}

\lpdef\@dc@AddAndParse#1{%
  \dc@addtoParsed@{#1}%
  \@dc@falsify@xadefaults
  \@dc@ParseNextSpecifier
}


\def\grab@optparam #1{% arg specifier
  \@ifnextchar\bgroup{\@dc@AddAndParse}%
  {%
    \edef\@dc@tempa{%
      \gmu@if {csname}%
      {@dc@optparam@deft@\strip@bslash{#1}\endcsname}%
      {\@xaucs {@dc@optparam@deft@\strip@bslash{#1}}}%
      {\@nx \NoValue}%
    }%
    \@xa\@dc@AddAndParse\@xa{\@dc@tempa}%
  }%
}


\long\def\@dc@DeclareDefault #1#2{%
  \uppercase{%
    \Name\edefU{\strip@bslash{\@dc@optparam@deft@}\strip@bslash{#1}}{#2}}%
  %
  \lowercase{%
    \Name\edefU{@dc@optparam@deft@\strip@bslash{#1}}{#2}}%
}

\@dc@DeclareDefault D{0}
\@dc@DeclareDefault d{0}

\@ifXeTeX {%
  \@dc@DeclareDefault Ď{0}%
}
{}

\@xa\@dc@DeclareDefault \@xa\Scope\@xa{\all@stars}

\@dc@DeclareDefault = {\@tempcnta}


\@dc@DeclareDefault Q {\NoValue}

\@ifXeTeX {%
  \@dc@DeclareDefault Ô{\NoValue}%
}
{}

\@dc@DeclareDefault U {\NoValue}

\long\def\@dc@maybe@expandafter #1{%
  \gmu@if {@dc@xadefault}{}%
  {\gmu@ifutokens{#1}{\NoValue}%
    {\@secondoftwo}{\@firstoftwo}%
  }% if we are to expandafter |#1|.
  {\@secondoftwo}% if we don't expandafter |#1|
}

\long\def\dc@addtotoks@ #1{%
  \@dc@maybe@expandafter {#1}%
  %
  {\toks@\@xa\@xa\@xa{\@xa\the\@xa\toks@\@xa{#1}}}%
  {\toks@\@xa{\the\toks@{#1}}}%
}

\long\def\@dc@addtospecs #1{%
  \@dc@maybe@expandafter {#1}%
  {\@xa \addtotoks \@xa\@dc@ParsedSpecs\@xa{\@xa{#1}}%
  }%
  {\addtotoks\@dc@ParsedSpecs{{#1}}}%
}

\long\def\dc@addtoParsed@ #1{%
  \dc@addtotoks@{#1}%
  \@dc@addtospecs{#1}%
}

\long\def\@dc@addtospecs@bare #1{%
  \addtotoks\@dc@ParsedSpecs{#1}%
}

\long\def\@dc@addtotoks@bare #1{%
  \addtotoks\toks@ {#1}%
}

\long\def\@dc@addtoParsed@bare #1{%
  \@dc@addtotoks@bare {#1}%
  \@dc@addtospecs@bare {#1}%
}

\long\def\grab@twoparams
#1% the specifier
#2% first parameter, which is mandatory
{% default default (when default is absent)
  \if@dc@xadefault@i@\@dc@xadefaulttrue\fi
  \dc@addtoParsed@{#2}%
  \if@dc@xadefault@ii@
    \@dc@falsify@xadefaults\@dc@xadefaulttrue
  \fi
  \grab@optparam{#1}%
}

\long\def\@dc@addargum#1{%
  \addtotoks\@dc@arguments{#1}%
\@iwruif {@@@@@@ @dc@arguments: »\the\@dc@arguments«}%
}

\Store@Macro\@dc@addargum

\pdef\@dc@ignorearg{%
  \long\def\@dc@addargum##1{%
    \Restore@Macro\@dc@addargum}%
}

\StoreMacro@nocat\gmu@passbraced

\pdef\@dc@BareSpaceArg{%
  \let \gmu@passbraced \gmu@passbracedNotSp
  \def\@dc@addargum {%
    \Restore@Macro\@dc@addargum
    \Restore@Macro\gmu@passbraced
    \@dc@addargum
  }%
}


\def\grab@prefix@CASE{% just a shorthand
  \@xa\gmu@CASEsbany\gmu@forarg
}

\long\def\grab@prefix #1{%
  %% \CH{2010/07/26  v0.993 made for-eaching to make it behave as
  %% expected, i.e.\ that latter settings prævalent over the former}
  %
  \gmu@foreach#1\gmu@foreach@delim {%
    %
    \grab@prefix@CASE
    {\long!lL\par Pp}%
    {\@dc@long@true}%
    %
    \grab@prefix@CASE
    {Ii}%
    {\@dc@ignore@true}%
    %
    \grab@prefix@CASE
    {\@xa\expandafter}%
    {\@dc@xadefaulttrue}%
    %
    \grab@prefix@CASE
    {\@xa \@xa@nx \@xa@xa \expandafter \@xanx \xanx \xaxa}%
    {\@dc@xadefault@i@true}%
    %
    \grab@prefix@CASE
    {\@xa \@nx@xa \@xa@xa \expandafter \@nxxa \nxxa}%
    {\@dc@xadefault@ii@true}%
    %
    \grab@prefix@CASE
    {\@xaeacher \xaeacher \xaEacher \xaE }%
    {\@dc@xadefault@ii@true}%
    %
    \grab@prefix@CASE
    {\GroteNegere \GrossIgnore \GroteN \GrossI}
    {\@dc@GroteNegere@true
      \@dc@ignore@true}%
    %
    \grab@prefix@CASE
    {\GroteNegereStop\GrossIgnoreStop
      \GroteNStop\GrossIStop}
    {\@dc@GroteNegere@false
      \@dc@ignore@false}%
    %
    \grab@prefix@CASE
    {\GroteLang\GrossLong\GroteL\GrossL}
    {\@dc@GroteLang@true
      \@dc@long@true}%
    %
    \grab@prefix@CASE
    {\GroteLangStop\GrossLangStop
      \GroteLStop\GrossLStop}%
    {%
      \let\if@dc@GroteLang@=\if@dc@alllong@
      \let\if@dc@long@=\if@dc@alllong@
    }%
    %
    \grab@prefix@CASE
    {\BareSpace}
    {\@dc@BareSpace@true}
    %
    %
    \gmu@EatCases
    {\IgnInfo{gmcommand}{while parsing arg specifiers}{#1}}%
    \gmu@ESAC
    %
  }% of for each
    \@dc@ParseSpecifier %
}% of |\grab@prefix|

\long\def\dc@DefParseNext#1{%
  % This is to allow hashes in the defaults.
  \edefU\@dc@parse@next{#1}%
}

\def\@dc@Alias
#1% |\lowercase| or |\firstofone|
#2% left side of the assignment
#3% right side of the assignment
#4% |Lower| or empty
{%
  \gmu@if {csname}%
  {ArgumentCatcher@\strip@bslash #3\endcsname}%
  {#1{%
      \@xa\let\csname\strip@bslash\ArgumentCatcher@
      \strip@bslash #2\@xa\endcsname}%
    \csname ArgumentCatcher@\strip@bslash #3\endcsname
  }{\PackageError{gmutils/gmcommand}{%
      You're trying to #4Alias the »\unexpanded{#3}« catcher^^J%
      but it is not defined!}{}%
  }%
}

\def\@dc@LowerAliases #1{%
  % To provide  lowercase aliases of the catchers:
  \@dc@Alias \lowercase {#1}{#1}{Lower}%
  \@dc@Alias \lowercase {\P#1}{\P#1}{Lower}% we provide »P« as a \CS
                                % to avoid lowercase'ing it.
}

\def\@dc@AliasCatcher
#1% left side of the assignment
#2% right side of the assignment
{%
  \@dc@Alias \firstofone {#1}{#2}{}%
}

\def\@dc@AliasPLower
#1% specifier to alias
{\@dc@AliasCatcher {P#1}{#1}%
  \@dc@LowerAliases{#1}%
}

\long\def\ArgumentCatcher@B
#1% default value
#2%  tail of args catchers.
\@dc@arguments % delimiter
{%
  \@ifnextcat\bgroup
  {\dc@DefParseNext{#2}\ArgumentCatcher@m@i }%
  {\@dc@addargum {{#1}}#2\@dc@arguments }%
}

\long\def\ArgumentCatcher@PB
#1% default value
#2%  tail of args catchers.
\@dc@arguments % delimiter
{\@ifnextcat\bgroup
  {\dc@DefParseNext{#2}\ArgumentCatcher@Pm@i }%
  {\@dc@addargum {{#1}}#2\@dc@arguments }%
}

\@dc@LowerAliases B

\long\def\ArgumentCatcher@T@ % parsing of a~single \textbf Token
                             % continued:
#1% kind of test (|strings| or |StrX| so far (2010/12/28,  7.24))
#2%  the list to search |#4| on,
#3% the default value,
#4% the tail of args parsers,
#5% the token we search in |#1|  (it's an unbraced
{%
  #1 #5{#2}%
  {\@dc@addargum {{#5}}#4\@dc@arguments}%
  {\@dc@addargum {{#3}}#4\@dc@arguments#5}%
}

\long\def\ArgumentCatcher@T % parsing of a~ single \textbf Token. It's
#1% the list we search optional token on,
#2% the default value,
#3%  the tail  of args parser.
\@dc@arguments{%
  \@ifnextnotgroup
  % \label{dc@S:bgroup}
  {\ArgumentCatcher@T@ \gmu@ifStrXany {#1}{#2}{#3}}%
  {\@dc@addargum {{#2}}#3\@dc@arguments}% if we parse an
  % opening or closing brace, then we are sure it's not any expected
  % Single.
}

\@dc@AliasPLower T

\long\def\ArgumentCatcher@Ť #1#2#3% as in |›…@T|
{% one-token catcher that respects space.
  \ArgumentCatcher@Loop
  {StrX}{\any}{#1}{\any}{}{1}{#2}{% empty eacher
  }{#3}%
}

\@dc@AliasPLower Ť


\edef\ArgumentCatcher@S
#1% default value
{%
  \@nx\ArgumentCatcher@T {\@xa\@nx\all@stars}{#1}}% the |s| arg spec is

\@dc@AliasPLower S
\@dc@AliasCatcher * S

\newif\if@debugacro@

\long\def\ArgumentCatcher@Loop  %^^A >>>>>>>loop
#1% kind of test (|StrX| or |str| or anything else for what
#2% “sign” of match for iteration: |\any| or |\none|
#3% list of tokens |\@let@token| will be matched against with |#1|
#4% test for “drainers” (allowed values as for |#1|)
#5% list of “drainers”: if |\@let@token| satisfies the |#3| test,
#6% upper bound of number of items (may be empty or negative to turn
#7% default value (if empty sequence is parsed), |\NoValue| by default.
#8% an “eacher”—stuff to be put before each token/text added to the
#9% the tail of args parser
\@dc@arguments % delimiter
{%
  \dc@DefParseNext{#9}%
  \emptify\@dc@seQuence
  \c@dc@Loop@bound=\numexpr(\gmu@ifempty{#6}{-1}{#6})*1\relax
  \gmu@if {num}{\c@dc@Loop@bound<\z@}%
  {\c@dc@Loop@bound=-\c@dc@Loop@bound
    \let\@dc@Loop@countby\z@
  }%
  {\let\@dc@Loop@countby\m@ne}%
  %
  \gmu@ifempty{#3}%
  {\gmu@if {strings}{\none #2}%
    {\@dc@Loop@iteralltrue}% it's an additional switch for better
    % performance in a special case: when we wish
    % only count the items and iterate over anything
    {%
      \Store@Macro\ArgumentCatcher@Loop@defcheck
      \def\ArgumentCatcher@Loop@defcheck{%
        \Restore@Macro\ArgumentCatcher@Loop@defcheck
        \ArgumentCatcher@Loop@shipout}%
    }% of if |#2| str-is |\any|
  }% of if |#3| empty
  {\@dc@Loop@iterallfalse}% when |#2| nonempty, we \emph{have} to
  % perform matching. \rrthis
  %
  \gmu@ifempty{#5}%
  {\gmu@if {strings} {\none #4}%
    {\@dc@Loop@addallfalse\@dc@Loop@drainalltrue}%
    {\@dc@Loop@addalltrue\@dc@Loop@drainallfalse}%
  }% of if |#5| empty
  {\@dc@Loop@addallfalse\@dc@Loop@drainallfalse}% when |#4| nonempty,
  % we \emph{have} to perform matching. \rrthis
  %
  \edef\ArgumentCatcher@Loop@afterpeep{%
    \gmu@if {@dc@Loop@iterall}{}%
    {\firstoftwo}%
    {\unexpanded{%
        \@dc@Loop@test
        {#1}#2{#3}% if the next token StrX-is/is not on |#2|,
        % then… \label{h1.@let@token.h2}
      }% of |\unexpanded|
    }% of if we don't iterate over all (of preparation of iteration test)
    {\gmu@if {@dc@Loop@addall}{}%
      {\@nx \ArgumentCatcher@Loop@add}%
      {\gmu@if {@dc@Loop@drainall}{}%
        {\@nx \ArgumentCatcher@Loop@drain}%
        {\unexpanded{%
            \@dc@Loop@test
            {#1}#4{#5}% if the next token satisfies |#4|-direction StrX/str
            % match against |#5|, then we discard it,
            % otherwise we add it.
            \ArgumentCatcher@Loop@drain
            \ArgumentCatcher@Loop@add
          }% of |\unexpanded|
        }% of not drain all
      }% of if not add all
    }%
    {\gmu@if {@dc@Loop@iterall}{}%
      {}%
      {\@nx \ArgumentCatcher@Loop@shipout}%
    }%
    \unexpanded{{#7}{#8}}%
  }% of |\ArgumentCatcher@Loop@afterpeep|
  %
  \ArgumentCatcher@Loop@defcheck {#7}{#8}%
  \ArgumentCatcher@Loop@check
}% of |\ArgumentCatcher@Loop|

\newcount\c@dc@Loop@bound

\newif\if@dc@Loop@iterall
\newif\if@dc@Loop@addall
\newif\if@dc@Loop@drainall

\long\def\@dc@Loop@test
#1% kind of test (|StrX| or |str| so far (2010/12/28,  7.51))
#2% |\any| or |\none|
#3% list of tokens to match against
#4% what if \OK
#5% what if not \OK.
{% remember we are in the argument of |\gmu@peep@next| so we are after
  % peep.
 \gmu@if {defined}{\@def@token}
 {\csname gmu@if#1\strip@bslash #2\@xa\endcsname
   \@def@token }%
 {\csname
     gmu@if%
     \gmu@ifdetokens {#1}{str}%
     {NX}%
     {x}%
     \strip@bslash #2%
   \endcsname
   \@let@token }%
 {#3}{#4}{#5}%
}

\@dc@AliasCatcher {PLoop} {Loop}

\long\def\ArgumentCatcher@Loop@defcheck
#1% default,
#2% “eacher”
{%
  \edefU\ArgumentCatcher@Loop@check{%
    \gmu@if {num}{\c@dc@Loop@bound>\z@}
    {\advance \c@dc@Loop@bound \@dc@Loop@countby
      \gmu@peep@next
      \ArgumentCatcher@Loop@afterpeep }
    {\ArgumentCatcher@Loop@shipout {#1}{#2}}% of if num bound reached
  }% of |\ArgumentCatcher@Loop@check|
}% of |\ArgumentCatcher@Loop@defcheck|

\lpdef\@dc@Loop@CareOfSpace
#1% a macro with all the arguments except last
{\gmu@ifpeeped x \gmu@letspace
  {\edef\@dc@Loop@careofspace@aas{%
      \unexpanded{#1{ }}%
    }% edef unexpanded to allow |#| tokens in |#1|
    \afterassignment\@dc@Loop@careofspace@aas
    \let\gmu@drain= }% after |=| is a space.
  {#1}% next not space, so just |#1| and let it process the next token
  % its way.
}

\StoreMacro@nocat\@dc@Loop@CareOfSpace

\lpdef\@dc@Loop@CareOfSpace@NoBraces
#1% a macro with all the arguments except last
{%
\gmu@ifpeeped x \gmu@letspace
  {\edef\@dc@Loop@careofspace@aas{%
      \unexpanded{#1 }% note the space
    }% edef unexpanded to allow |#| tokens in |#1|
    \afterassignment\@dc@Loop@careofspace@aas
    \let\gmu@drain= }% after |=| is a space.
  {#1}% next not space, so just |#1| and let it process the next token
  % its way.
}


\lpdef\@dc@Loop@CareOfSpaceAndGroup
#1% as in the previous macro
{\@iwruif {Care of both: @let@token: »\meaning\@let@token«}%
  \@dc@Loop@CareOfSpace{%
    \gmu@passbraced{#1}%
  }%
}% of “take care of both”

\long\def\ArgumentCatcher@Loop@add
#1% default
#2% eacher
{\@dc@Loop@CareOfSpaceAndGroup
  {\ArgumentCatcher@Loop@add@{#2}}%
}

\long\def\ArgumentCatcher@Loop@add@
#1%  eacher
#2%  token/text to be added
{\addtomacro\@dc@seQuence{#1#2}%
  \@iwruif {@@@@@@ Q-add: »\the\@dc@arguments«}%
  \ArgumentCatcher@Loop@check
}% of  |\ArgumentCatcher@Loop@add@|

\long\def\ArgumentCatcher@Loop@drain
#1% default
#2% eacher
{%
  \@iwruif{@@@@@@ Q-drain: »\the\@dc@arguments«}%
  \@dc@Loop@CareOfSpaceAndGroup
  {\@xa\ArgumentCatcher@Loop@check\@gobble}%
}

\long\def\ArgumentCatcher@Loop@shipout
#1% default
#2% eacher
{%
  \gmu@if x{\@dc@seQuence\@empty}%
  {\def\@dc@seQuence{#1}%
    \gmu@if x{\@dc@seQuence\@empty}%
    {}{\prependtomacro\@dc@seQuence{#2}}%
  }%
  {}% if |\@dc@seQuence| is nonempty, we don't modify it.
  \@xa\@dc@addargum\@xa{\@xa{\@dc@seQuence}}%
  \@iwruif {@@@@@@ Q-finish: »\the\@dc@arguments«}%
  \@dc@parse@next\@dc@arguments
}% of |\ArgumentCatcher@Loop@shipout|

\long\def\ArgumentCatcher@Q
#1% list
#2% default (|\NoValue| by default, as in previous versions).
{%
  \ArgumentCatcher@Loop
  {StrX}%
  \any
  { #1}% note the space before |#1|—settheory sum of |#1| and drainers.
  \any
  { }% we ignore spaces—it's a legacy setting, maybe we'll optionise
  % it in the future
  \m@ne % we allow any number of tokens
  {#2}% default, by default |\NoValue|, as defined in line \ref{Q-arg deft.}
  {}% empty eacher
}%

\@dc@AliasPLower Q

\@ifXeTeX {%
  \long\def\ArgumentCatcher@Ô
  #1% list
  #2% default (|\NoValue| by default, as in previous versions).
  {%
    \@dc@BareSpaceArg
    \ArgumentCatcher@Loop
    {str}%
    \any
    { #1}% note the space before |#1|—settheory sum of |#1| and drainers.
    \any
    { }% we ignore spaces—it's a legacy setting, maybe we'll optionise
    % it in the future
    \m@ne % we allow any number of tokens
    {#2}% default, by default |\NoValue|, as defined in line \ref{Q-arg deft.}
    {}% empty eacher
  }%

  \@dc@AliasPLower Ô

}{}% of if \XeTeX

\def\ArgumentCatcher@D{% decimal argument (useful for dates e.g.)
  \ArgumentCatcher@Q
  {-+0123456789}%
  % the default value will be delivered by the defaults' catcher
}

\@dc@AliasPLower D

\@ifXeTeX
{%
  \def\ArgumentCatcher@Ď
  #1% default value, 0 by default
  {% decimal argument
    \ArgumentCatcher@Loop
    {StrX}%
    \any
    {-+0123456789}%
    \any
    {}%
    \m@ne
    {#1}%
    {}%
  }%

\@dc@AliasPLower Ď

}{}% of if \XeTeX

\def\ArgumentCatcher@U {%
  \ArgumentCatcher@Loop {StrX}%
}

\@dc@AliasPLower U

\@dc@AliasCatcher W {U}

\@dc@AliasPLower W

\@dc@AliasCatcher {lostwax} U % ^^A Catcher@lostwax

\long\def\ArgumentCatcher@item
#1% “sign” of matching
#2% list to match against
#3% default value
#4% eacher (which in this case will be applied to \emph{the} (one)
{%
  \ArgumentCatcher@Loop
  {StrX}%
  #1%
  {#2}%
  \none {}% we add all that matches
  1 % at most one item
  {#3}%
  {#4}%
}

\if@XeTeX

  \def\ArgumentCatcher@Ǔ{%
    \@dc@BareSpaceArg
    \ArgumentCatcher@Loop {StrX}%
  }

  \@dc@AliasPLower Ǔ

\fi


\long\def\ArgumentCatcher@genM
#1% the letter »P« (for long catcher) or nothing (for the short version)
#2% number of undelimited parametrs to catch (arabic)
#3% tail of parsers
\@dc@arguments{%
  \dc@DefParseNext{#3}%
  \csname ArgumentCatcher@#1m@%
  \romannumeral#2%
  \endcsname
}


\def\ArgumentCatcher@M{\ArgumentCatcher@genM {}}
\def\ArgumentCatcher@PM{\ArgumentCatcher@genM P}

\@dc@AliasCatcher {m} {M}
\@dc@AliasCatcher {Pm} {PM}

\@dc@AliasCatcher {ms} {M}
\@dc@AliasCatcher {Pms} {PM}

\@tempcnta=\@ne
\@whilenum\@tempcnta<9\do{%
  %
  \edef\gmu@tempa{%
    %
    % The short catchers of mandatories:
    \def\@xanxcs{%
      ArgumentCatcher@m@\romannumeral\@tempcnta}%
    \gmu@hashes1{\numexpr\@tempcnta+1}%
    {\@nx\@dc@addargum{%
        \gmu@hashesbraced 1{\numexpr\@tempcnta+1}}%
      \@nx\@dc@parse@next\@nx\@dc@arguments
    }% of \incs{ArgumentCatcher@m@\<rom.num>}.
    %
    % And  the long ones:
    \long \def\@xanxcs{%
      ArgumentCatcher@Pm@\romannumeral\@tempcnta}%
    \gmu@hashes1{\numexpr\@tempcnta+1}%
    {\@nx\@dc@addargum{%
        \gmu@hashesbraced 1{\numexpr\@tempcnta+1}}%
      \@nx\@dc@parse@next\@nx\@dc@arguments
    }% of \incs{ArgumentCatcher@Pm@\<rom.num>}.
    %
  }% of |\edef|.
  \gmu@tempa
  \advance\@tempcnta1\relax
}% of the loop.

\if 1 1
\@tempcnta\@ne
\@whilenum\@tempcnta<9\do{%
  \typeout{\bslash  ArgumentCatcher@m@\romannumeral\@tempcnta:    ^^J%
    \Name\meaning{ArgumentCatcher@m@\romannumeral\@tempcnta}^^J}%
  \typeout{\bslash  ArgumentCatcher@Pm@\romannumeral\@tempcnta : ^^J%
    \Name\meaning
    {ArgumentCatcher@Pm@\romannumeral\@tempcnta}^^J^^J^^J%
  }%
  \advance\@tempcnta\@ne
}

\fi

\def\ArgumentCatcher@m@ix
#1#2#3#4#5#6#7#8#9{%
  \@dc@addargum{%
    {#1}{#2}{#3}{#4}{#5}{#6}{#7}{#8}{#9}}%
  \the \@dc@arguments
}

\long\def\ArgumentCatcher@Pm@ix
#1#2#3#4#5#6#7#8#9{%
  \@dc@addargum{%
    {#1}{#2}{#3}{#4}{#5}{#6}{#7}{#8}{#9}}%
  \the \@dc@arguments
}

\long\def\ArgumentCatcher@K %  a~Knuthian delimited or undelimited
#1% the particular Knuthian macro
#2%   the tail of args parser.
\@dc@arguments % tail delimiter
{\dc@DefParseNext{#2}#1}

\@dc@AliasPLower K

\long\def\gmu@twostring#1#2{\string#1\string#2}

\long\def\ArgumentCatcher@G@longorshort
#1% longness prefix (|\long| or nothing)
#2% left and right delimiters
#3% default value
#4% the tail of args parser.
\@dc@arguments % tail delimiter
{%
  \edef\@dc@Gname{ArgumentCatcher@G\gmu@twostring#2}%
  \gmu@if {csname}{\@dc@Gname \endcsname}%
  {}%
  {#1\Name\def{\@dc@Gname \@xa}%
    \@dc@Gparams#2{\@dc@addargum{{##2}}##1\@dc@arguments}%
  }%
  \@xa\@ifEUnextchar\@firstoftwo#2%
  {\def\dc@parse@next{#4}% we hide possible |\par|s.
    \csname \@dc@Gname \endcsname\dc@parse@next}%
  {\@dc@addargum{{#3}}#4\@dc@arguments}%
}

\long\def\@dc@Gparams#1#2{##1#1##2#2}

\lpdef\ArgumentCatcher@G % short general catcher
#1% left and right delimiters
#2% default value
{\ArgumentCatcher@G@longorshort{}{#1}{#2}}

\lpdef\ArgumentCatcher@PG % long general catcher
#1% left and right delimiter
#2% default value
{\ArgumentCatcher@G@longorshort{\long}{#1}{#2}}

\def\@dc@DefAsGeneral
#1% specifier
#2% delimiters
{\Name\lpdef{ArgumentCatcher@\strip@bslash{#1}}%
  ##1% default value
  {\ArgumentCatcher@G{#2}{##1}}%
  \Name\lpdef{ArgumentCatcher@P\strip@bslash{#1}}%
  ##1% default value
  {\ArgumentCatcher@PG{#2}{##1}}% »P« was missing. Fixed 2011/03/22, 16.14.
  %
  \gmu@if {cat}{a\@nx#1}%
  {\@dc@LowerAliases #1}{}%
}

\@dc@DefAsGeneral A{<>}

\@dc@DefAsGeneral O{[]}


\def\DCnocoordinate{\@dc@DefAsGeneral C{()}}
\DCnocoordinate

\edefU\DCcoordinate{%
  %
  \long\def\ArgumentCatcher@C
  #1% default value
  #2% tail of parsers
  \@dc@arguments % tail's delimiter
  {%
    \@ifEUnextchar(%^^A)
    {\dc@DefParseNext{#2}\ArgumentCatcher@c@}%
    {\@dc@addargum{{#1}}#2\@dc@arguments}%
  }%
  %
  \let\ArgumentCatcher@c\ArgumentCatcher@C
  \let\ArgumentCatcher@Pc\ArgumentCatcher@PC
  %
  \long\def\ArgumentCatcher@PC#1#2\@dc@arguments{%
    \@ifEUnextchar(%^^A)
    {\dc@DefParseNext{#2}\ArgumentCatcher@Pc@}%
    {\@dc@addargum{{#1}}#2\@dc@arguments}%
  }%
  %
  \def\ArgumentCatcher@c@(#1){%
    \gmu@ifxany,{#1}%
    {\@xa\@dc@addargum\@dc@commasep#1\@dc@commasep}%
    {\@dc@addargum{{#1}}}\@dc@parse@next\@dc@arguments
  }%
  % \stanza
  \def\@dc@commasep#1,#2\@dc@commasep{{{{#1}{#2}}}}%
  % \stanza
  \long\def\ArgumentCatcher@Pc@(#1){%
    \gmu@ifxany,{#1}%
    {\@xa\@dc@addargum\@dc@commasep#1\@dc@commasep}%
    {\@dc@addargum{{#1}}}\@dc@parse@next\@dc@arguments
  }%
}


\def\@dc@Scope@shipout#1{%
  \ifx\@dc@seQuence\@empty\def\@dc@seQuence{#1}\fi
  \@xa  \gmu@ifxany\@xa \global\@xa{\@dc@seQuence}%
  {\@dc@addargum{{\global}}}%
  {\@dc@addargum{{\relax}}}%
  \@dc@parse@next\@dc@arguments
}

\def\ArgumentCatcher@Scope
#1% the separator(s)
{\let\@dc@seQuence@shipout@@\@dc@seQuence@shipout
  \let\@dc@seQuence@shipout\@dc@Scope@shipout
  \ArgumentCatcher@Q{\global\relax}{\relax}%
  \let\@dc@seQuence@shipout\@dc@seQuence@shipout@@
  \@dc@ignorearg
  \ArgumentCatcher@T{#1}{\NoValue}%
}

\@dc@AliasCatcher {PScope} \Scope


\long\def\gmuIfNoValueTF#1{% % \chgs{2008/12/1 v0.98 the \pk{xparse} tests for
  % the presence of value redefined and much simplified (43 \CS'es
  % less). Moreover, they are now fully expandable: \cmd\gmuIfNoValueTF,
  % \cmd\gmuIfNoValueT, \cmd\gmuIfNoValueF, \cmd\gmuIfValueTF, \cmd\gmuIfValueT,
  % \cmd\gmuIfValueF}
  %
  % \chgs{2010/05/27 v0.993 bug fix: order of \cmd\NoValue and
  % \cs{@firstofmany} reversed after a catastrophal |{11}{11}| argument}
  \@xa\ifx\@xa\NoValue\@firstofmany#1\@empty\@nil \afterfi\@firstoftwo
  \else\afterfi\@secondoftwo
  \fi}

\long\def\gmuIfNoValueT#1#2{\gmuIfNoValueTF{#1}{#2}\@empty}

\long\def\gmuIfNoValueF#1#2{\gmuIfNoValueTF{#1}\@empty{#2}}

\long\def\gmuIfValueTF#1#2#3{\gmuIfNoValueTF{#1}{#3}{#2}}

\long\def\gmuPutIfValue#1{\gmuIfValueT{#1}{#1}}

\let\gmuIfValueT\gmuIfNoValueF

\let\gmuIfValueF\gmuIfNoValueT

\long\pdef\IfLong#1{%\
  % \begin{enumargs}
  % \item the argument to check for |\par|,
  % \item what if |\par| found,
  % \item what if |\par| not found.
  % \end{enumargs}
  %
  \edef\gmu@IfLong@resa{\detokenize{#1}}%
  \edef\gmu@IfLong@resa{%
    \IfAmong\string\par\@nx\among{\gmu@IfLong@resa}}%
  \gmu@IfLong@resa}


\long\@namedef{ArgumentCatcher@=}%
#1% register used in the assignment
#2%  the tail  of args parser.
\@dc@arguments{%
  \dc@DefParseNext{%
    \@dc@addargum\NoValue  % to make ignoring mechanism work
    #2\@dc@arguments}%
  \afterassignment\@dc@parse@next
  #1}% optional space and |=| is left at user's discretion. In fact,

\n@melet{ArgumentCatcher@P=}{ArgumentCatcher@=}


\long\def\ArgumentCatcher@gobblespace
{\ArgumentCatcher@T {\dc@gobblespace@dummy}{\NoValue}}

\let\ArgumentCatcher@Pgobblespace\ArgumentCatcher@gobblespace

\def\dc@gobblespace@dummy{\dc@gobblespace@dummy}

\let\gobblespace\dc@gobblespace@dummy


\errorcontextlines=100

\long\def\@dc@InnerName#1{%
  \bslash@or@ac{#1}%
  \bslash
}%

\long\def\@dc@InnerEndName #1{% version for the end-macros of environments
  \bslash end\strip@bslash{#1}%
}%

%% \CH{2010/07/26  v0.993 This strikingly simple idea of storing the
%% specifiers' sequence in a macro came to my head only after some
%% three years of developing \cmd\DeclareCommand}
\long\edef\@dc@SpecsArName#1{%
  Specs \string& arity of
  \@nx\bslash@or@ac{#1}%
}%

\pdef\@dc@messages {%
  \gmu@notif {@dc@quiet@}{}%
  {%
    \gmu@if {DCMessages}{}%
    {\PackageInfo{gmcommand}{^^J%
        Parsing arguments for \dc@innername^^J%
        [specified as:
        \unexpanded
        \@xa\@xa\@xa \@xa\@xa\@xa \@xa{%
          \@xa\@xa\@xa\@secondofmany
          %
          % not |\@secondofthree| because first use of this definition is for
          % |\DeclareCommand| not having its specifiers' carrier.
          %
          \csname \@dc@specsname\endcsname {}{}\@nil }%
        \space ]^^J%
        [in file: \@currname.\@currext\space ]}% of info message
    }% of if \ac DC messages
    {}% of if not |DCMessages|
  }% of if not |@dc@quiet@|
  {}% of if not not |@dc@quiet@|
}% of |\@dc@messages|


\edefU\@dc@DCbody {%
{% \label{DC:final}  %
                 % \chgs{2008/12/05 v0.98 added the \cs{@bsphack}---\cs{@esphack} option}
                 % \chgs{2008/12/07 v0.98 added the \env{Q\arg{tokens}} argument type
                 %   (a~word over the alphabet \<tokens>)}
  \edef\dc@innername {\@dc@InnerName #1}% we'll use it in |K|-type arg.\ catcher and
  \edef\@dc@specsname  {\@dc@SpecsArName{#1}}%
  \gmu@ifCSdefined {#1}%
  {\gmu@if{DCMessages}{}%
    {\PackageWarning{gmcommand}{%
        ^^J%
        Redefining command \dc@innername\space
        with \string\DeclareCommand}%
    }%
    {}%
  }%
  {\gmu@if {DCMessages}{}%
    {\PackageInfo{gmcommand}{^^J%
        \string\DeclareCommand-ing \dc@innername\space (new)^^J}%
    }%
    {}%
  }%
  \@dc@alllong@false
  \@dc@quiet@false
  %
  \emptify\@dc@Specs@tempa
  %
  \gmu@ifsbintersect{#2}{\long!lL}{%
    \addtomacro\@dc@Specs@tempa{\long}%
    \@dc@alllong@true}%
  {}%
  %
  \gmu@ifsbintersect{#2}{.qQ\quiet}{%
    \addtomacro\@dc@Specs@tempa{\quiet}%
    \@dc@quiet@true}%
  {}%
  %
  \gmu@ifsbintersect{#2}{iIwW\sphack}%
  {% if `invisibility' is specified: \UnDef
    \addtomacro\@dc@Specs@tempa{\sphack}%
    \def\@dc@bsphack@{\@nx\@bsphack}% \UnDef
    \def\@dc@esphack@{\@nx\@esphack}%
  }%
  {\emptify\@dc@bsphack@
    \emptify\@dc@esphack@}% if `invisibility' is not specified.
  %
  \gmu@ifsbany\envhack{#2}%
  {% but  if we define an environment:
    \addtomacro\@dc@Specs@tempa{\envhack}%
    \emptify\@dc@bsphack@
    \emptify\@dc@esphack@
    \edef\@dc@setThrowArgs{%
      \dc@ThrowArgs{\string#1}}% if our command is used
  }%
  {% and if we don't define an environment:
    \emptify\@dc@setThrowArgs
  }%
  %
  \relaxen\@dc@global@
  \relaxen\@dc@outer@
  %
  \gmu@ifsbany\outer{#2}%
  {\addtomacro\@dc@Specs@tempa{\outer}%
    \let\@dc@outer@\outer}%
  {}%
  %
  \gmu@ifsbany\global{#2}{%
    \addtomacro\@dc@Specs@tempa {\IAmDeclaredGlobally}%
    \let\@dc@global@\global}%
  {}%
  %
  \@xa\Name \@xa\edefU
  \@xa\@dc@specsname
  \@xa{\@xa{\@dc@Specs@tempa}}%
  \@dc@ResetParseAuxilia
  %
  \@dc@ParseNextSpecifier #3%
  \@dc@buckstopshere % it's the sentinel of parsing. Since the test
  %
  \@xa \Name \@xa \addtomacro \@xa \@dc@specsname
  \@xa {\@xa{\the\@dc@ParsedSpecs}}%
  %
  \@xa\Name\@xa\addtomacro\@xa\@dc@specsname
  \@xa{\@xa{\the \c@dc@argnum}}%
  %
  \@dc@outer@\@dc@global@ % possibly the prefixes,
%%%%%
%%%%%% Here comes the definition of the coating macro, named the
%%%%%% same as the command:
  \protected\edef#1{% always |\protected| \balsmiley( ;-)
    \@dc@bsphack@ % perhaps |\@bsphack|
    %
    \@dc@messages
    %
    \@nx\@dc@{\the\toks@}% in the braces appear the argument catchers.
    \@xanxcs{\dc@innername}%
    \ifx\@dc@outer@\outer
      \@xanxcs{\@xa\gobble\string#1 }% note the blank
    \else \@nx #1%
    \fi
  }% of main coating macro's |\edef|. \UnDef
  %
  \edef\gmu@DeclareCommand@resa{%
    \@dc@global@ % perhaps |\global|
    \long\def\@xanxcs{\@dc@InnerName{#1}}% for a~command
    \@xau\@dc@innerhashes % it's |#1#2#3…|
    {% the body of the inner ‘|\\⁄<name>\|’ macro:
      \@dc@setThrowArgs
      \unexpanded{#4}%
      \@dc@esphack@}%
  }% of |\edef|.
  \gmu@DeclareCommand@resa
}% of |\DeclareCommand|'s body.
}

\def\@dc@DCprefixQlist{\global\protected\outer\long
  \relax % for the somewhat perverse case when |\@dc@global| may be
  !lL.qQiIwW\sphack\envhack}

\long\def\ShowCommand #1{%
  \@iwruJ
  \@iwru{»\string#1« is »\meaning#1«}%
  \@iwruJ
  \@iwru{»\Name\string{\@dc@InnerName{#1}}« is
    »\Name\meaning{\@dc@InnerName{#1}}«}%
  \@iwruJ
  \@iwru{»\Name\string{\@dc@SpecsArName{#1}}« is
    »\Name\meaning{\@dc@SpecsArName{#1}}«}%
  \@iwruJ
  \show\show
}

\@XA{\DeclareCommand\DeclareCommand   % This is the final version by now.\
{
  #1 >Pm       %   command to be defined (may be even \incs{par} if you
  #2 >\@xa Q{\@dc@DCprefixQlist}{} %\
  #3 >Pm % arguments specification (may contain \incmd\par),
  #4 >Pm %  the definition body; may contain nearly anything including
}}\@dc@DCbody


\@XA{\DeclareCommand \DeclareCommand \long
  {m >\@xa Q{\@dc@DCprefixQlist}{} mm}}%
\@dc@DCbody


\long\def\dc@EAName#1{% Env.\ arguments' toks' name
  \if\bslash#1\else#1\fi's_args}

\pdef\dc@ThrowArgs#1{%
  \gmu@if{csname}{\dc@EAName{#1}\endcsname}
  {}% if it's defined, we do nothing (we assume it's defined by us and
    % is toks register.)
  {% else we define it as a new toks
  % \label{'s args}
    \@xa\newtoks\csname\dc@EAName{#1}\endcsname
  }%
  \csname\dc@EAName{#1}\endcsname=%
  \@xa\@xa\@xa{\@xa\@gobble\the\@dc@arguments}%
}%


\def\@dc@K@defaultrepl{##1}

\DeclareCommand\@dc@define@K \long {mb}{% \label{K@parse}
  %  First we add the particular \CS to the toks register:\nostanza
  \edef\gmu@tempa{%
    \unexpanded{\toks@\@xa}%
    {\@nx\the\toks@{%
        \@xanxcs{\dc@innername @K\the\c@dc@catchernum}%
      }%
    }%
    % here we add to the parsers toks list a \CS\ named
    % |\⁄<our command>@K⁄<num. of catcher>| (the particular Knuthian catcher)
  }\gmu@tempa
  %  and define this macro: \nostanza
  \edef\gmu@tempa{%
    % And now we define that particular Knuthian catcher.
    \def\@xanxcs{\dc@innername @K\the\c@dc@catchernum}%
    \gmu@if {@dc@xadefault@i@}{}%
    {\@xau{#1}}%
    {\unexpanded{#1}}%
    {%
      \@nx\@dc@addargum{{%
          \gmuIfValueTF{#2}{%
            \gmu@if{@dc@xadefault@ii@}{}%
            {\@xau{#2}}%
            {\unexpanded{#2}}%
          }{\@xau{\@dc@K@defaultrepl}}%
        }}% we add the Knuthian
      % replacement to the toks register as \inhash n.
      \@nx \@dc@parse@next \@dc@arguments
    }% and continue parsing.
  }% of |\edef|. Now we execute this temporary macro, which means we \incmd\def|\⁄<command>@K⁄<n>|
  \@dc@global@ % set properly before |\@dc@ParseNextSpecifier #3⁄<buck>|.
  \if P\@dc@long@letter\relax\long\fi
  \gmu@tempa
  %
  \@dc@addtospecs {#1}%
  %
  \gmuIfValueTF{#2}{%
    \gmu@if{@dc@xadefault@ii@}{}%
    {\@xa\@dc@addtospecs\@xa{#2}}%
    {\@dc@addtospecs{#2}}%
  }
  {\@xa\@dc@addtospecs\@xa{\@dc@K@defaultrepl}}%
  %
  % Now we clean up and continue construction of arguments parser. \nostanza
 \@dc@ParseNextSpecifier
}% of |\@dc@define@K|

\DeclareCommand\@dc@grab@Loop \long {%
  #1 T{\any \none Uu\U \u Ǔǔ\Ǔ \ǔ Ww\W \w \lostwax} % the “sign” of matching for adding; use of
  % the letters suppresses adding them to the
  % parsed specifiers' list, which is crucial for
  % |\SameAs| copying of specifiers: the “until” and “while” loops
  % don't shift their arguments.
  %
  #2 >Pm % list of tokens to match for/against iteration
  %
  >i T{\drain \drop \Drain \Drop \lost \Lost}
  #3 T{\any \none }{\any} % the “sign” of matching for draining
  %
  #4 b{} % list of drainers, empty by default
  %
  >i T{\count \ubound}
  #5 D{\m@ne} % upper bound of iterations
  %
  >i T{\default \Default}
  #6 b % default value (|\NoValue| by default)
  %
  #7 T{\eacher \Eacher \defEacher} % default is |\NoValue| and that's no
                                % harm since we test if |#7| == |\defEacher|.
  #8 B{} % eacher, empty by default
}{%
  %
  \@dc@process@matchsign {#1} {##1}%
  %
  \dc@addtoParsed@{#2}%
  %
  \gmu@if {strings}{\lostwax#1}%
  {\gmu@if {@dc@xadefault}{}%
    {\@xa\edefU\@xa\@dc@LostWaxList\@xa{#2}}%
    {\edefU\@dc@LostWaxList{#2}}%
  }%
  {}%
  %
  \@dc@process@matchsign {#3} {##3}%
  %
  \dc@addtoParsed@{#4}%
  %
  \@xa  \@dc@addtospecs@bare \@xa{\the\numexpr #5}%
  \@dc@addtotoks@bare{{#5}}% to ignore possible expandafter.
  %
  \dc@addtoParsed@ {#6}%
  %
  \gmu@if {strings}{\defEacher#7}
  {%
    \Name\def{\dc@innername/defdEacher/\the\c@dc@argnum}%
    ##1{#8}%
    %
    \Name \dc@addtoParsed@
    {\dc@innername/defdEacher/\the\c@dc@argnum}%
  }
  {\gmu@if {@dc@xaeacher@}{}
    {\@dc@xadefaulttrue}{\@dc@xadefaultfalse}%
    \dc@addtoParsed@ {#8}%
  }%
  %
  \gmu@if {strings}{\lostwax#1}
  {\grab@LostWax}
  {\@dc@ParseNextSpecifier}%
}

\DeclareCommand\grab@LostWax {
  >iT{\lost \Lost}
  #1 b{\lostwax@NoVal}
  >iT {\count \ubound}
  #2 D{1}
  >iT{\endlost \EndLost}
}{%
  % We build an ignored “while” catcher.
  %
  \def\@dc@LostWaxA{>iw}%
  %
  \gmu@ifdetokens {\lostwax@NoVal}{#1}
  {%
    % if no particular value of the “lost wax” is provided, we assume
    % the same as the “until” delimiter(s).
    %
    \prependtomacro\@dc@LostWaxA{>\@xa}%
    \addtomacro\@dc@LostWaxA{\@dc@LostWaxList}%
  }%
  %
  % Otherwise first we check whether “lost wax” provided has nonempty
  % intersection with the “until” delimiters.
  {%
    \@xa\gmu@ifstrintersect
    \@xa{\@dc@LostWaxList}{#1}
    {\addtomacro\@dc@LostWaxA{{#1}}}%
    {\PackageError{gmutils/gmcommand}{^^J%
       You try to declare a "Lost Wax" catcher^^J%
       with the "Lost" list disjoint with the "Until" list.^^J%
       I assume sum of them}%
     {}%
     %
     \@xa \addtomacro\@xa\@dc@LostWaxA
     \@xa{\@xa{\@dc@LostWaxList #1}}%
   }%
 }%
 %
 \addtomacro\@dc@LostWaxA{ \count #2 \relax}%
 %
 \@xa\@dc@ParseNextSpecifier \@dc@LostWaxA
}% of |\grab@LostWax|.

\def\@dc@process@matchsign
#1% the argument
#2% its numeral in human language (for the error message)
{%
  \gmu@CASE {strings} {{#1}\any }
  {\@dc@addtoParsed@bare {\any }}%
  %
  \gmu@CASEsbany {#1} {Ww}
  {\@dc@addtotoks@bare {\any}}%
  %
  \gmu@CASE {strings} {{#1}\none}
  {\@dc@addtoParsed@bare {\none }}%
  %
  \gmu@CASEsbany {#1} {UuǓǔ\lostwax }
  {\@dc@addtotoks@bare {\none }}%
  %
  \gmu@lastCASE
  {\PackageError{gmcommand}{%
      You *have* to declare »\string\any« or »\string\none« ^^J%
      as the #2 argument for the »\string\loop« catcher}{}%
  }%
  \gmu@ESAC
}

\long\pdef\UnDeclareCommand#1{%
  \let#1\@undefined
  \ifcsname\@dc@InnerName{#1}\endcsname
    \n@melet{\@dc@InnerName{#1}}{@undefined}%
  \fi
  \ifcsname\@dc@SpecsArName{#1}\endcsname
    \n@melet{\@dc@SpecsArName{#1}}{@undefined}%
  \fi
}


\edef\gmu@tempa{%
  \def\@nx\gmu@ifHashless@##1%
  \detokenize{macro:}##2->##3\@nx\@nil}%
\gmu@tempa
{\gmu@if {}{\gmu@ifempty{#2}{1}{0}\gmu@ifempty{#3}{2}{1}}}

\long\edef\gmu@ifHashlessMacro
#1% a \CS, name or active char
{%
  \edef\@nx\gmu@WHL@arg{\@nx\@xanxtri{#1}}%
  \unexpanded{\@xa\@xa\@xa\gmu@ifHashless@
    \@xa\meaning\gmu@WHL@arg}%
  \relax % to ensure that |#3| of |\gmu@ifHashless@| is nonempty
  % if match for the delimiters is found earlier
  \detokenize{macro:***->}\@nx\@nil % the sentinels
}

\long\def\gmu@ifDeclared#1{%
  % \begin{enumargs}
  % \item a \CS or csname or an active char,
  % \item true branch,
  % \item false branch  %
  % \end{enumargs}
  \let\gmu@ifDe@next\@secondoftwo
  %
 %
  \gmu@CASEnot {csname} {\@dc@SpecsArName{#1}\endcsname}%
  {}%
  %
  \gmu@CASEnot {csname}{\@dc@InnerName{#1}\endcsname}%
  {}%
  %
  \gmu@EatCases
  {\gmu@ifHashlessMacro{#1}%
    {\edef\gmu@ifDe@resa{%
        \@nx\gmu@ifxany\@xanxcs{\@dc@InnerName{#1}}%
        {\unexpanded\@xa\@xa\@xa{\gmu@WHL@arg}}%
        % Above: to get the contents of the outer macro we use the macro
        % carrying conversion of possible name into a \CS and expand
        % it twice. Then we freeze it with |\unexpanded|.
        {\let\@nx\gmu@ifDe@next\@nx\@firstoftwo}% if the inner macro
        % is present in the
        % contents of |#1|, we take the first implicit argument
        {}% otherwise we do nothing (taking the second implicit is
        % already set)
      }% of edef
      \gmu@ifDe@resa
    }% of if a hashless macro
    {}% of if not a hasless macro
  }%
  %
  \gmu@ESAC
  \gmu@ifDe@next
}% of |\gmu@ifDeclared|

\long\def\@dc@SameAs#1{%
  \gmu@ifDeclared {#1}%
  {%
    \@xa\@xa\@xa \@xa\@xa\@xa \@xa
    \@dc@ParseNextSpecifier
    \@xa\@xa\@xa \@secondofthree
    \csname \@dc@SpecsArName{#1}\endcsname
  }%
  {%
    \PackageError{gmcommand}{%
      Command \@nx#1 ^^J%
      is not declared with \DeclareCommand. ^^J%
      I can't repeat its parameters in current command declaration}%
    {}%
  }%
}% of |\@dc@SameAs|

\DeclareCommand\DCUse{
  #1  >Pm % the command
}{% ^^A with star we automatically pass the
  \gmu@ifDeclared{#1}%
  {%
    \@dc@arguments\@xa{\@xa
      \csname \@dc@InnerName{#1}\endcsname
    }%
    %
    \csname ArgumentCatcher@Pm@\romannumeral
    \@xa \@xa \@xa \@thirdofthree
    \csname \@dc@SpecsArName{#1}\endcsname % of arity carrier
    \endcsname % of the catcher
  }%
  {\DC@EndNotDeclaredErr{#1}}%
}%

\pdef \DC@EndNotDeclaredErr #1{%
  \PackageError{gmcommand}{%
    Command \bslash end\strip@bslash{#1} ^^J%
    is not declared with \DeclareCommand. ^^J%
    Therefore I can't use its DC-inner macro (because of its nonexistence).^^J}%
  {}%
}

\DeclareCommand\DCUseEnd{
  #1  >Pm % the command (without “end”)
}{%
  \gmu@ifDeclared{end\strip@bslash{#1}}%
  {%
    \@dc@arguments\@xa{\@xa
      \csname \@dc@InnerEndName{#1}\endcsname
    }%
    %
    \csname ArgumentCatcher@Pm@\romannumeral
    \@xa \@xa \@xa \@thirdofthree
    \csname \@dc@SpecsArName{#1}\endcsname % of arity carrier
    \endcsname % of the catcher
  }%
  {\DC@EndNotDeclaredErr{#1}}%
}%


\DeclareCommand\DeclareEnvironment \long
{
  #1--#4  \SameAs \DeclareCommand
  % We repeat the specifiers, but the role of |#4| is slightly
  % different here: here it's the |\begin| part definition.
  %
  #5 m %    the end definition; it \emph{can} contain any
  %   \inverb|#|\<n>---the arguments of the environment are passed
  %   to it, too.
}{%
  \def\gmu@DeclareEnvironment@resa{\envhack}%  we add the information we define an
  % environment.
  \gmuIfValueT{#2}%
  {\addtomacro\gmu@DeclareEnvironment@resa{#2}}% we pass all the ‘prefixes’ to
  % \incs{Decl\+are\+Comm\+and}
  % \stanza
  \@xa\DeclareCommand\csname#1\@xa\endcsname
  \gmu@DeclareEnvironment@resa{#3}{#4}%
  %
  %\nostanza Now the begin definition is done. Let's get down to the
  %end definition. \nostanza
  %
 \let\@dc@env@endglobal=\@dc@global@ % note this \CS was for sure redefined by the last
  % \incs{Decl\+are\+Com\+m\+and} (and by nothing else) and that's
  % exactly what we want.
  \edef\gmu@DeclareEnvironment@resb{%
    \@nx\@xa
    \@xanxcs{\bslash end#1}%
    \@nx\the
    \@xanxcs{\dc@EAName{#1}}%
  }% of |\edef|. It reuslts in
  % \[|\@xa \\end⁄<name> \the\\⁄<name>'s_args|\]
  % which does not collide with the inner macro of the |\end›…|
  % command, since the latter is |\\end›…\|.
\gmu@if{csname}{\dc@EAName{#1}\endcsname}{\gmu@namelet\global{\dc@EAName{#1}}{@undefined}}{}%
  \edef\gmu@DeclareEnvironment@resa{% \UnDef
    \@dc@global@\long\def % the inner end macro is always \incmd\long\
    % and perhaps defined \incmd\global ly.
    \@xanxcs{\bslash end#1}%
    \@xau\@dc@innerhashes % it's |#1#2#3›…|---the inner end macro takes the
    % same number of parameters as the begin macro.
    {% the definition body
      \unexpanded{#5}}%
  }% of |\edef›…@resa|.
  \gmu@DeclareEnvironment@resa
  \edef\gmu@DeclareEnvironment@resc{%
    \DeclareCommand\@xanxcs{end#1}%
    \@dc@env@endglobal
    {}% no parameters
    {\@xau    {\gmu@DeclareEnvironment@resb
        \@ignoretrue}%
    }%
  }%
  \gmu@DeclareEnvironment@resc
  %
  %
}% of |\DeclareEnvironment|

\DeclareCommand\NewCommand
{\SameAs\DeclareCommand}
{%
  \gmu@ifCSdefined {#1}
  {\DCUse\DeclareCommand#1{#2}{#3}{#4}}%
  {\PackageError{gmcommand}%
    {Command \@nx#1 already defined \on@line!}%
    {}%
  }%
}

\DeclareCommand\RenewCommand
{\SameAs\DeclareCommand}
{%
  \gmu@ifCSdefined {#1}
  {\DCUse\DeclareCommand#1{#2}{#3}{#4}}%
  {\PackageError{gmcommand}%
    {Command \@nx#1 not yet defined \on@line!}%
    {}%
  }%
}

\DeclareCommand\ProvideCommand
{\SameAs\DeclareCommand}
{%
  \gmu@ifCSdefined {#1}
  {}
  {\DCUse\DeclareCommand#1{#2}{#3}{#4}}%
}

\DeclareCommand\NewEnvironment
{\SameAs\DeclareEnvironment}
{%
  \gmu@ifdefined{#1}
  {\DCUse\DeclareEnvironment{#1}{#2}{#3}{#4}{#5}}%
  {\PackageError{gmcommand}
    {Environment #1 already defined \on@line!}{}%
  }%
}

\DeclareCommand\RenewEnvironment
{\SameAs\DeclareEnvironment}
{%
  \gmu@ifdefined {#1}
  {\DCUse\DeclareEnvironment{#1}{#2}{#3}{#4}{#5}}%
  {\PackageError{gmcommand}
    {Environment #1 not yet defined \on@line!}{}%
  }%
}


\DeclareCommand\XeTeXthree{o}{% \
  % \changes{v0.90}{2008/8/4}{adjusted
  %   to the redefinition of
  %   \cs{verb} in \pk{xlxtra} 2008/07/29}
  \@ifXeTeX{%
    \gmuIfValueT{#1}{\PassOptionsToPackage{#1}{fontspec}}%
    \@ifpackageloaded{gmverb}%
    {%
      \Store@Macro\verb
      \StoreEnvironment{verbatim}%
      \StoreEnvironment{verbatim*}%
    }{}%
    \RequirePackage{xltxtra}% since v 0.4 (2008/07/29) this package
    % redefines |\verb| and \env{verbatim*},
    % and quite elegantly provides an option
    % to suppress the redefinitions, but
    % unfortunately that option excludes also
    % a~nice definition of |\xxt@visiblespace|
    % which I~fancy.
    \@ifpackageloaded{gmverb}%
    {%
      \Restore@Macro\verb
      \RestoreEnvironment{verbatim}%
      \RestoreEnvironment{verbatim*}%
    }{}%
    %
    \AtBeginDocument{%
      \@ifpackageloaded{gmlogos}{%
        \Restore@Macro\LaTeX\Restore@MacroSt{LaTeX }% my version of the
        % \LaTeX\ logo has been stored just
        % after defining, in line \ref{SMLaTeX}. \ilrr
        \Restore@Macro\eTeX}%
      {}%
    }%
    % \stanza
    \pdef\adddefaultfontfeatures##1{%
      \addtomacro\zf@default@options{#1,}}
  }% of |\@ifXeTeX|'s first argument,
  {}% |\@ifXeTeX|'s second argument,
}% of |\XeTeXthree|'s body.

\DeclareCommand\setspaceskip{%
  A{1}% optional factor for all three components
  O{\fontdimen2\font}%
 >is
 O{\fontdimen3\font}%
 >is
 O{\fontdimen4\font}}
{\spaceskip=\glueexpr\dimexpr#2*#1\relax plus\dimexpr #3*#1\relax
  minus\dimexpr#4*#1\relax\relax}

\pdef\unsetspaceskip{%
  \spaceskip=\z@skip
}

\def\makestarlow{%
  \begingroup\lccode`\~=`\*\lowercase{%% \Define**
    \endgroup\def~{\gmu@lowstar}}% 2009/10/19  |\let| changed to
  % \inverb|\def| to allow redefinitions of \incmd\gmu@lowstar.
  \catcode`\*=\active
  \defLowStarFake
}

\DeclareCommand\defLowStarFake{%
  Q{+-0123456789,.}{0,5}% fraction of fontchar depth of the star glyph
}%
{%
  \def\gmu@lowstarfake{%
    \leavevmode\vbox{\hbox{*}\kern#1\fontchardp\font`*}%
  }%
}

\def\gmu@lowstarfake{*} % useful for next command where normal star is

\DeclareCommand\enoughpage{%
  #1  D{\NoValue} % (optional short version (number of
                  % |\baselineskip|s)) Before 2010/9/10 the default
                  % value was the |D|-default, i.e., 0, which lead to
                  % improper working of this command.
  #2  B{2\baselineskip}% (2) optional (formerly mandatory) long version of
  % required room on a page
  >is
  #3 >PB{} % (3) what if the room is enough
  >is
  #4 >PB{\newpage} % (4) what if there's to little room on a page
}{%
  % \chgs{2009/03/18 v0.98 made \eTeX-ish}
  % \chgs{2009/05/25 v0.98 made ifthenelse-like with ‘then’ and ‘else’
  %   optional default \<nothing> and \cmd\newpage resp.}
  % \chgs{2009/10/21 v0.98 \cmd\par\ removed since to let it be used
  %   for \cmd\pagebreak\ inside a paragraph}
  \gmu@if {num}
  {\numexpr
      \ifdim
        % if the space left is less than we wish then 1, otherwise 0.
        \gmu@pageremain
        <%
        \dimexpr
          (\gmuIfValueTF{#1}{#1\baselineskip}{#2})*1%
        \endexpr
        %
        % \CH{2010/06/28  v0.993 I added |(›…)*1| to assure that |\relax|
        %   really delimits the dimexpr}
        %
        1\else 0%
      \fi
      *%
      \ifdim \gmu@pageremain >-1sp
        1% if the room left on current page is nonnegative,
        % then we indeed are on current page so “enough” and
        % “not enough” does make sense: Enough is enough.
      \else 0% otherwise we are on next page (or further) and assume
        % there is enough room for our purpose.
      \fi
      *%
      \ifdim \pagegoal <\maxdimen
        1 % if there are some boxes on current page, so checking room
        % does make sense.
      \else 0% otherwise (no boxes on current page) assume there's
             % enough room
      \fi
    >\z@
  }% of condition
  {\typeout{@@@@@ not enough page \on@line}%
    #4%
  }%
  {#3}%
}

\long\def\gmu@LC@LetInners
#1% scope prefix (|\global| or |\relax|
#2% left side
#3% right side of the assignment
{%
  \edef\gmu@LC@InnerLeft{\@dc@InnerName{#2}}%
  \edef\gmu@LC@InnerRight{\@dc@InnerName{#3}}%
  %
  \gmu@namelet{#1}{\gmu@LC@InnerLeft}{\gmu@LC@InnerRight}%
  \edef\gmu@LC@InnerLeft{\@dc@SpecsArName{#2}}%
  \edef\gmu@LC@InnerRight{\@dc@SpecsArName{#3}}%
  %
  \gmu@namelet{#1}{\gmu@LC@InnerLeft}{\gmu@LC@InnerRight}%
}

\long\def\gmu@CL@PrepareArg
#1% left/right
#2% |\@xa| or |\edef|, maybe sth.\ more in the future
#3% a \CS, text of a name or an active char
{%
  \Name\let{gmu@CL@#1}\@undefined
  \ifx\@xa#2\Name\edef{gmu@CL@#1}{\@xau{#3}}\fi
  \ifx\edef#2\Name\edef{gmu@CL@#1}{#3}\fi
  \unless\ifcsname gmu@CL@#1\endcsname
    \Name\edef{gmu@CL@#1}{%
      \gmu@if{cat}{\@nx~\@nx#3}%
      {\@nx#3}{\strip@bslash{#3}}%
    }%
  \fi
}

\DeclareCommand\CommandLet \long {%
  \Scope % (1)
  T{\@xa\edef} % (2) whether left side should be |\expandaftered|
  m % (3) left side of assignment
  >iT{=} % pro forma
  T{\@xa\edef} % (4) whether right side should be |\expandaftered|
  m % (5) right side of the asssignment
}{%
  %
  \gmu@CL@PrepareArg{left}#2{#3}%
  \gmu@CL@PrepareArg{right}#4{#5}%
  %
  \@xa\gmu@ifDeclared\@xa{\gmu@CL@right}{%
    \edef\gmu@LC@resa{%
      \DeclareCommand %
      \@xa\@xanxtri\@xa{\gmu@CL@left}%
      #1% scope prefix
      {\@nx\SameAs\@xa\@xanxtri\@xa{\gmu@CL@right}}% args. spec
      {}% the body of the command will be |\let| via letting inners.
    }%
  %
    \gmu@LC@resa
    \@XA{\@xa\gmu@LC@LetInners\@xa#1%
    \@xa{\gmu@CL@left}}\@xa{\gmu@CL@right}%
  }% of if Declared
  {% if not Declared, we just |\let|:
\if\@nx#3ѥ\typeout{@@@@@ »\@xa\@dc@InnerName\@xa{\gmu@CL@right}« is not
  Declared?: \Name\meaning{\@xa\@dc@InnerName\@xa{\gmu@CL@right}}%
}%
\show\NotDeclared
\fi
    \@XA{\@xa\tri@let\@xa#1%
      \@xa{\gmu@CL@left}}\@xa{\gmu@CL@right}%
  }%
}

\DeclareCommand\envirlet \long{\Scope mm}{% for |\let|ting environments.
  \CommandLet #1{#2}{#3}%
  \CommandLet #1{end#2}{end#3}%
}

\DeclareCommand\@fornum{%
  m% (1) initial (least) num. value
  m% (2) limit (last iterated over) num. value
  O{1}% (3) step of iteration
  m% (4) body of the loop
}%
{\edef\gmu@fornum@min{\the\numexpr #1}%
  \edef\gmu@fornum@lim{\the\numexpr #2}%
  \let\gmu@fornum@curr\gmu@fornum@min
  \@whilenum\gmu@fornum@curr<\gmu@fornum@lim
  \do{#4%
    \edef\gmu@fornum@curr{%
      \the\numexpr\gmu@fornum@curr+#3}%
  }% of |\@whilenum|'s body.
}% of |\@fornum|.

\pdef\StoreCommand{%
  \begingroup
  %\label{SC begr}
  \MakePrivateLetters
  \@StoreCommand
}

\long\def\gmu@SC@StorageName
#1% a \CS, name or active char
#2% group level
{%
  \gmu@storeprefix/%
  \ifnum\numexpr#2>-1 \the\numexpr(#2)*1\relax\fi
  \bslash@or@ac {#1}%
}%

\def\gmu@SC@setgrouplevel
#1% |+›⁄|-⁄|\NoValue|
#2% a decimal number
{\edef\gmu@SC@grouplevel{%
    \the\numexpr
    \gmuIfValueTF{#1}%
    {\currentgrouplevel#1#2+1}{#2}%
  }% of the grouplevel-carrying macro
}

\DeclareCommand\@StoreCommand
{%
  #1 T{+-}% grouplevel shift indicator
  #2  d % group level or shift (the latter relative to the current g.l.)
  #3  >Pm% name or \CS
}{%
  \endgroup %we close the group opened in line \ref{SC begr}.
  \gmu@SC@setgrouplevel{#1}{#2}%
  %
  \edef\gmu@SC@resa{%
    \gmu@SC@StorageName{#3}{\gmu@SC@grouplevel}}%
  %
  \let\gmu@SC@scope\relax
  \ifnum\gmu@SC@grouplevel>\currentgrouplevel
    \let\gmu@SC@scope\global
  \fi
  \@xa\CommandLet\@xa\gmu@SC@scope\@xa{\gmu@SC@resa}{#3}%
}

\pdef\StoreEnvironment{%
  \begingroup
  \MakePrivateLetters
  \@StoreEnvironment
}

\def\@StoreEnvironment#1{%
  \@StoreCommand{#1}%
  \begingroup
  \@StoreCommand{end#1}%
}

\pdef\RestoreEnvironment{%
  \begingroup
  \MakePrivateLetters
  \@RestoreEnvironment
}

\def\@RestoreEnvironment#1{%
  \endgroup
  \RestoreCommand{#1}%
  \RestoreCommand{end#1}%
}

\pdef\UseStored{%
  \begingroup
  \MakePrivateLetters
  \@UseStored}


\DeclareCommand\@UseStored \long{%
  #1  T{+-}% (1) indicator of grouplevel shift (in distiction from an absolute
  % group level)
  #2 d % (2) optional grouplevel or shift (0 by default)
  #3  O{\@gobble}% (3) stuff to be put before the |#4| \CS, e.g., an
  #4  m % (4) a \CS or csname to be taken from the storage liquid
}{%  \chgs{2010/06/23 v0.993 added}
  \endgroup
  \gmu@SC@setgrouplevel{#1}{#2}%
  \edef\gmu@SC@grouplevel{%
    \the\numexpr\gmu@SC@grouplevel+1}% for the first turn of loop
  %
  \loop
    \edef\gmu@SC@grouplevel{%
      % we decrease the group level number
      \the\numexpr\gmu@SC@grouplevel-1}%
    %
    \edef\gmu@SC@currname{%
      % define the cs' storage name for that level
      \gmu@SC@StorageName{#4}{\gmu@SC@grouplevel}}%
  \ifnum
  % and check the conjunction of conditions: the group level is >=-1…
    \unless\ifnum\gmu@SC@grouplevel<-1 1\else 0\fi
    % and the csname remains not defined.
    \unless\ifcsname \gmu@SC@currname \endcsname 1\else 0\fi
    =11
  \repeat
  \gmu@if{csname}{\gmu@SC@currname\endcsname}%
  {%
    % ^^A     \s how\ExecutingTrueBranch
    \@XA{#3{#4}}\csname \gmu@SC@currname\endcsname}% first
  {%
    % ^^A \s how\ExecutingFalseBranch
    #3{#4}\@undefined}% second
}% of |\@UseStored|

\DeclareCommand\RestoreCommand{\Scope d}{%
  \UseStored #2[\CommandLet #1*]%
}


\newbox\gmu@smashbox

\DeclareCommand\set@smashbox{%
  \Scope
  T{hv}{h}
}{#1\setbox\gmu@smashbox =\csname #2box\endcsname }%

\def\smash@box{\smash{\box\gmu@smashbox}}


\newbox\gmu@boxA
\newbox\gmu@boxB
\newdimen\gmu@dima
\newdimen\gmu@dimb

\DeclareCommand\gmu@extremebox {
  #1  m % a dimen register (will be assigned the extr.\ value) or a
  % \CS (will be defined as |\the| extreme value)
  #2  T {\min\max}{\max} % kind of extreme
  #3  T {\wd\ht\dp\totalheight}{\wd} % dimension to compare, the last two for total |\ht|+|\dp|.
  #4  \lostwax {\global\relax} \eacher{\gmu@dimextreme@step} \lost{\relax}
  #5  T{\global}{} % scope of assignment
}{%
  \gmu@if x {\max#2}
  {\gmu@dimb=-\maxdimen
    \def\gmu@dimextreme@comp{<}%
  }
  {\gmu@dimb=\maxdimen
    \def\gmu@dimextreme@comp{>}%
  }%
  %
  \long  \def\gmu@dimextreme@step ##1{%
    \setbox\gmu@boxA=\hbox{##1}%
    %
    \gmu@dima= \gmu@if x {\totalheight#3}
    {\dimexpr \ht\gmu@boxA +\dp\gmu@boxA\relax}
    {#3\gmu@boxA}%
    \relax
    %
    \gmu@if {dim}
    {\gmu@dimb\gmu@dimextreme@comp \gmu@dima }
    {\gmu@if {dim} {\gmu@dima>\z@}
      {\gmu@dimb=\gmu@dima }
      {}%
    }
    {}%
    %
  }%
  %
  #4%
  \IfIs #1\dimen
  {#5#1=\gmu@dimb}
  {#5\edef #1{\the\gmu@dimb }}%
}%

\pdef\gmu@getht
#1% box register
#2% dimen (or glue) register to assign the (substitute) height to
{%
  \setbox\gmu@boxA=\copy#1\relax
  \ifvbox\gmu@boxA
    \vbadness@M
    \setbox\gmu@boxB=\vsplit\gmu@boxA to \maxdimen
    \vbadness@Restore
    %
    % chcemy rzeczywiście pomierzyć, a nie być może odrzucić odstępy,
    % kerny i grzywny.
    \setbox\gmu@boxB=\vbox{\splitdiscards }%
    \ifdim \ht\gmu@boxB >\z@
      \setbox \gmu@boxA=\vbox{
        \unvbox\gmu@boxB
        \unvbox\gmu@boxA
      }%
    \fi
  \else
    \setbox\gmu@boxA=\box\voidb@x
  \fi
  %
  \ifvoid\gmu@boxA
    #2=\ht#1\relax
  \else
    #2=\maxdimen
  \fi
}% of |\gmu@getht|



\DeclareCommand\enlargefsize{
  #1  m % enlargement (dim(expr)) for font size
  #2  b % enlargement (dim(expr)) for baselineskip (if absent, |#1| is used)
}{\edef\gmu@tempa{%
    \@nx\fontsize{\the\dimexpr\f@size pt+#1}%
    {\the\dimexpr 1\baselineskip+ \gmuIfValueTF{#2}{#2}{#1}}%
  }\gmu@tempa\selectfont
}

\DeclareCommand\scalefsize {
  #1 m % scale for font size
  #2 b % scale for baselineskip (if absent,  |#1| is used)
  \gobblespace
}{\edef\gmu@tempa{%
    \@nx\fontsize{\the\dimexpr #1\dimexpr\f@size pt\relax}%
    {\the\dimexpr  \gmuIfValueTF{#2}{#2}{#1}\baselineskip}%
  }\gmu@tempa\selectfont
}

\let\gmu@discretionaryhyphen\- % for the cases when we don't redefine
                               % \incs\- but use \incs\UrlFix

\DeclareCommand\bihyphen{
  O{*} % token that'll make the discretionary hyphen |\-| allow other break-points
}{%
  \DeclareCommand\gmu@discretionaryhyphen{%
    T{#1}%
    G{&&}%
    a
  }{%
    \gmuIfValueT{##2}{%
      \gmu@ifempty{##2}{}{%
        \def\gmu@bihyphen@char{##2}}%
    }%
    \gmuIfValueT{##3}{%
      \gmu@ifempty{##3}{}{%
        \def\gmu@bihyphen@corr{##3}}%
    }%
    %
    % Depending on |#1| we allow (if present, then we take |\discre|)
    % hyphenation of the word's before- and
    % after-parts or forbid it (if absent, then we take
    % |\discretionary|).
    \gmuIfValueTF{##1}\discre\discretionary
    {% before break
      \gmuIfValueTF{##2}
      {%
        \gmu@ifempty{##2}{\gmu@bihyphen@char}{##2}%
      }%
      {%
        \ifnum\hyphenchar\font>\z@
          \char\hyphenchar\font
        \fi}%
    }% end of before break
    {%after break
      \gmuIfValueT{##3}{%
        \gmu@ifempty{##3}{\gmu@bihyphen@corr}{##3}%
      }%
    }%
    {% without break
    }% almost as in \TB: unlike \TB, we allow hyphenchars
    % $\ge255$ as we are \XeTeX.
  }% of |\DeclareCommand\-|
  \gmu@storeifnotyet\-% original |\-| is a~\TeX's
  % primitive, therefore we should store it.
  \CommandLet\-\gmu@discretionaryhyphen
  \CommandLet\@dischyph\gmu@discretionaryhyphen % to override
                                % \pk{framed.sty}
  \pdef\gmu@flexhyphen{\gmu@discretionaryhyphen#1\relax}%
}% of |\bihyphen|

\relaxen\gmu@bihyphen@corr

\@ifXeTeX{%
  \DeclareCommand\gmshowlists {
    >iT{\depth}
    Ď{1}%
    >iT{\breadth}
    Ď{10000000}
  }%
}{% not in \XeTeX\ we use legacy |D| arg.\ specifiers:
  \DeclareCommand\gmshowlists {
    >iT{\depth}
    D{1}%
    >iT{\breadth}
    D{10000000}
  }%
}
{\tracingonline=\@ne
  \showboxdepth=#1\relax % how many levels of
                                % box nesting should be shown
  \showboxbreadth=#2\relax % after how many elements »etc.« will be put
  \showlists
}

\DeclareCommand\gmtracingoutput {
  \SameAs\gmshowlists
}
{\tracingonline=\@ne
  \tracingoutput=\@ne
  \showboxdepth=#1\relax % how many levels of
                                % box nesting should be shown
  \showboxbreadth=#2\relax % after how many elements »etc.« will be put
}


\newcount\c@FiBreakPenalty

\DeclareCommand \AllowFiBreak {%
   % The defaults are as in DEK's |\filbreak|.
   Q{l}{l}
   = {\c@FiBreakPenalty }
}
{%
   \penalty\@M
   \csname vfi#1\endcsname
   \penalty \c@FiBreakPenalty
   \csname vfi#1neg\endcsname
}


\DeclareCommand \IgnorePars {m Q{\par}} {#1}

\DeclareCommand\putpenalty {=}
{%
  \gmu@iflastglue
  {\@tempskipa=\lastskip
    \mode@skip -\@tempskipa
    \penalty \@tempcnta
    \mode@skip \@tempskipa
  }%
  {\gmu@iflastkern
    {\@temdima=\lastkern
      \kern-\@temdima
      \penalty \@tempcnta
      \kern \@temdima
    }
    {%
      \penalty\@tempcnta
    }%
  }%
}

\newskip \gmu@TrashSkip

\pdef \mode@skip {%
  \ifvmode \vskip
  \else
    \ifhmode \hskip
    \else
      \ifmmode \mskip
      \else
        \gmu@TrashSkip
      \fi
    \fi
  \fi
}


\endinput
%%
%% End of file `gmcommand.sty'.