trunk/Master/texmf-dist/source/latex/toolbox

git-svn-id: svn://tug.org/texlive/trunk@558 c570f23f-e606-0410-a88d-b1316a301751

2 files changed, 2881 insertions, 0 deletions

diff --git a/Master/texmf-dist/source/latex/toolbox/toolbox.dtx b/Master/texmf-dist/source/latex/toolbox/toolbox.dtx
new file mode 100644
index 00000000000..6d7bd8ee20c
--- /dev/null
+++ b/Master/texmf-dist/source/latex/toolbox/toolbox.dtx
@@ -0,0 +1,2859 @@
+% \def\fileversion{5.1}\def\filedate{2004/04/29}\def\docdate{2004/04/29}
+%\iffalse These lines are necessary for the doc and docstrip utilities
+%<*asciidocu>
+
+%%#
+%%# Author:
+%%#
+%%# M. V\"ath      vaeth@mathematik.uni-wuerzburg.de
+%%#
+%%# The author thanks
+%%#     David Kastrup <David.Kastrup@neuroinformatik.ruhr-uni-bochum.de>
+%%#
+
+%%#############################################################################
+%%#
+%%#  The TeX programmer's toolbox; enhanced version.
+%%#  This (La)TeX package provides some macros which are convenient for
+%%#  writing indices, glossaries, or other macros.
+%%#  It contains macros which support
+%%#
+%%#    - implicit macros - a useful supplement to \index or varindex for
+%%#      writing glossaries or indices
+%%#    - fancy optional arguments
+%%#    - loops over tokenlists and itemlists
+%%#    - searching, splitting, and replacing
+%%#    - controlled expansion
+%%#    - redefinition of macros
+%%#    - concatenated macro names
+%%#
+%%#############################################################################
+
+%%#
+%%# This package was tested with plain TeX, LaTeX 2.09, and LaTeX 2e,
+%%# and it should actually run with all TeX formats.
+%%#
+
+% If you have access to (reasonable new) docstrip TeXfiles, you should run
+% tex/latex on the file
+%   `toolbox.ins'
+% to produce the files `toolbox.sty', `toolbox.txt' and `toolbox.tex'.
+% (In case `toolbox.ins' is lost: You can find its content in the last
+%  few lines of the file you are currently reading between the
+%  lines %<*insfile> and %</insfile>;
+%  BTW: You should name this file here `toolbox.dtx' before you run tex
+%  on toolbox.ins).
+%
+% The file `toolbox.txt' contains a `brief' (but complete) ascii
+% documentation. If you have additionally access to LaTeX 2e, you may run
+% latex on the generated file `toolbox.tex' to produce `toolbox.dvi' which
+% contains a more luxury documentation.
+%
+% If you do not have access to the docstrip TeXfiles you may simply
+% copy/rename this file here into
+%   `toolbox.sty'
+% to use the package and read the ascii documentation in this file.
+% The ascii documentation (the content of `toolbox.txt') consists of all
+% lines in this file which start with %%# (this is the above block and another
+% (very large) block which follows soon).
+%
+% But I do not recommended this, because TeX will need more time to read this
+% longer file, and because there might be a (very slight) incompatibility if
+% you use it (namely if you load `toolbox.sty' with some *extremely* strange
+% catcodes).
+% I recommend in this case instead to generate the file `toolbox.sty' as
+% anything between the lines %<*package> and %</package> by hand.
+% (This is not precisely the file which you get with the docstrip TeXfiles,
+% but a reasonable good substitute. To speed up loading, you may also
+% eliminate all lines starting with `% ' in `toolbox.sty').
+% For your information: The file `toolbox.tex' produced by the docstrip
+% TeXfiles is anything between the lines %<*driver> and %</driver>
+% (with a line containing \endinput and two comment lines appended)
+%
+%
+% In any case, you end up with the file `toolbox.sty'.
+%
+% If you can generate `toolbox.tex', you will probably want to stop
+% reading now and instead read the `luxury' documentation in `toolbox.dvi'.
+%
+% Otherwise, you have to make due with the following ascii documentation.
+%
+%
+% \fi\catcode\#14\relax\iffalse  (This line is needed for the doc utility)
+%
+
+%%# To use toolbox, you have to put `toolbox.sty' in a path where TeX looks
+%%# for its input files. The TeX documents using toolbox need the
+%%# following modifications in their header:
+%%#
+%%# a) If you use LaTeX2.09, use toolbox as a style option, e.g.
+%%#      \documentstyle[toolbox]{article}
+%%#    or
+%%#      \documentstyle[toolbox,12pt]{article}
+%%# b) If you use LaTeX2e, put in the preamble the command
+%%#      \usepackage{toolbox}
+%%# c) If you use some other (non-LaTeX) format, you will probably have to
+%%#    insert a line like
+%%#          \catcode`\@=11\input toolbox.sty\catcode`\@=12\relax
+%%#
+%%# The only LaTeX-specific commands used in `toolbox.sty' are:
+%%#
+%%#   \newcommand (only in the form \newcommand{\command}{} to ensure that
+%%#                 \command was not defined before)
+%%#   \ProvidesPackage
+%%#   \typeout
+%%#
+%%#   The above commands are used only if they are defined.
+%%#
+
+%%#
+%%# Description of the provided macros:
+%%#
+
+%%# General remark: Many macros could appear in several sections.
+%%# For example, \toolboxMakeDef and \toolboxSourround might be considered
+%%# as macros which support redefinitions of macros. However, we put them
+%%# in different sections which perhaps explain better their nature.
+
+%%#
+%%# Implicit macro definitions
+%%# --------------------------
+
+%%# What we mean by implicit macro definitions is probably best explained by
+%%# the following examples which show the intended usage:
+%%#
+%%# (In the following examples, we always refer to the \index command. Note
+%%# that it may be more convenient to use for indices the varindex package in
+%%# addition - the documentation of varindex (release 2.3 or newer) gives
+%%# additional hints and examples how these two (essentially independent)
+%%# approaches can be combined in practice).
+%%#
+%%# Assume that you want to write an index for a book which has rather
+%%# long and complicated \index entries. The first idea that one might have in
+%%# this connection is to put the various \index commands at the beginning of
+%%# the document into several macros (one for each \index entry), and to use
+%%# just these macros in the main text. For example, one might want to write
+%%# near the beginning of the document commands like
+%%#   \newcommand{\Start}{\index{finish or end}}
+%%#   \newcommand{\End}{\index{finish or end}}
+%%# and then to use in the main text \Start and \End whenever a reference
+%%# in the corresponding index to the current place is desired.
+%%# However, this has two major disadvantages:
+%%#  1. Unless you are very disciplinary with your macro names, it is easy to
+%%#     forget that \End writes an index entry. So the \End in the main text
+%%#     might be very confusing.
+%%#  2. You cannot choose short and intuitive macro names for common phrases,
+%%#     because they are usually already reserved by TeX, LaTeX, or some
+%%#     packages.
+%%#
+%%# To avoid these problems, one may be very disciplinary and call the
+%%# involved macros systematically e.g. \GlossaryStart \GlossaryEnd etc.
+%%# However, this produces terrible long and unreadable macro names in the
+%%# main text.
+%%#
+%%# The implicit macro definitions of "toolbox" provide a more convenient
+%%# solution. The idea is that you do not use the corresponding macros directly
+%%# but only implicitly by a call of other macros where your "macro name" is
+%%# just an argument.
+%%# Moreover, "toolbox" assists you in writing the corresponding definitions.
+%%# For example, if you know that you want a set of macros which all expand
+%%# into something of the form \index{...}, you can give a ``mask'' which
+%%# contains this form, and you only have to fill in the changing content
+%%# (similarly as for usual TeX macros with arguments, but the level of
+%%# abstraction is one step higher).
+%%# For the above task, you might use the command:
+%%#
+%%#    \toolboxMakeDef{Glossary}{\index{#1}}
+%%#
+%%# The argument `Glossary' serves to distinguish independent definitions
+%%# (this will become clear later). Its effect visible now is that it
+%%# determines the name of the following macros which you can use after
+%%# the above call:
+%%#
+%%#    \NewGlossary{start-1}{start}
+%%#    \NewGlossary{start-2}{start or beginning}
+%%#    \NewGlossary{end}{finish or end}
+%%#
+%%# These command are now similar to the \newcommand definitions explained
+%%# above. However, there is no name collision with the TeX-internal command
+%%# \end. Of course, this means that you cannot just write \end in the main
+%%# text to get the desired index entry. Instead, you have to write the more
+%%# intuitive commands
+%%#
+%%#    \Glossary{start-1}
+%%#    \Glossary{start-2}
+%%#    \Glossary{end}
+%%#
+%%# (again, the name \Glossary stems from our first call of \toolboxMakeDef).
+%%# Note that e.g. \Glossary{start-1} expands not only to `start' but
+%%# actually to \index{start} (because of our first call of \toolboxMakeDef).
+%%# Note also that you can use symbols like - or numbers which are usually
+%%# not allowed in TeX macro names.
+%%#
+%%# Of course, similarly as for \newcommand, you can also do other things with
+%%# the macros. For example,
+%%#
+%%#    \LetGlossary\tempname{end}
+%%#    \NewGlossary*{finish}\tempname
+%%#
+%%# will first define \tempname to expand to the same text as \Glossary{end},
+%%# and then defines a new entry \Glossary{finish} to expand to the same text
+%%# as \tempname. Hence, the above new lines make the calls \Glossary{end} and
+%%# \Glossary{finish} equivalent.
+%%#
+%%# At the end of your list of \NewGlossary commands, you might want to put
+%%#
+%%#    \toolboxFreeDef*{Glossary}
+%%#
+%%# The purpose of this command is that \NewGlossary cannot be used anymore
+%%# (unless, of course, you define it again). So you cannot unintentionally
+%%# add new entries to your glossary list (but you still can use \Glossary{...}
+%%# to reference to the already produced entries).
+%%# Moreover, the above command frees some memory which was needed for
+%%# \NewGlossary to work.
+%%#
+%%# If you additionally want to free the memory used by \Glossary, you can use
+%%#
+%%#    \toolboxFreeDef{Glossary}
+%%#
+%%# (without the `*'). This may be necessary, if you want to call again e.g.
+%%#
+%%#    \toolboxMakeDef{Glossary}{\emph{#1}\index{#1}}
+%%#
+%%# (if you have not freed the memory for \Glossary before this repeated call,
+%%# TeX will complain that \Glossary is already defined).
+%%#
+%%# Of course, it is possible to call \toolboxMakeDef with several different
+%%# names, for example, for \Glossary, \SymbolList etc. Another application
+%%# might be to use a different command to mark e.g.\ the main occurrence of
+%%# some index entry or to output additionally the entry into the running text.
+%%# We do this in the following example which simultaneously
+%%# demonstrates that the names can also be constructed in another way:
+%%#
+%%#   \toolboxMakeDef[Ind]{}{\index{#1}}
+%%#   \toolboxMakeDef[Ind]{Main}{\index{#1|textbf}}
+%%#   \toolboxMakeDef{OutInd}{#1}
+%%#
+%%#   \IndNew{A}{A is a letter}
+%%#   \IndNewMain{A}{A is a letter}
+%%#   \NewOutInd{A}{\textbf{The letter A}\Ind{A}}
+%%#
+%%# After the above commands, you can use \Ind{A}, \IndMain{A}, and
+%%# \OutInd{A} to produce the corresponding \index entry, the "main" \index
+%%# entry (with a boldface page number), and the text \textbf{The letter A}
+%%# with an additional entry into the index, respectively.
+%%# Of course, it might usually be more convenient to define the \Ind and
+%%# \IndMain" entries simultaneously, e.g. as follows
+%%#
+%%#    \toolboxMakeDef[Ind]{}{#1}
+%%#    \toolboxMakeDef[Ind]{Main}{#1}
+%%#    \newcommand{\NewStandardInd}[2]{%
+%%#       \IndNew{#1}{\index{#2}}%
+%%#       \IndNewMain{#1}{\index{#2|textbf}}}
+%%#
+%%#    \NewStandardInd{A}{A is a letter}
+%%#
+%%# This approach has the additional advantage that you can define exceptional
+%%# cases "by hand" (e.g. if you want that for certain "main" index
+%%# entries the page number is printed with "\textsl" instead of "\textbf").
+
+
+%%# Since the motivation for implicit definitions now is hopefully clear,
+%%# let us now describe in detail which commands are provided by "toolbox"
+%%# for this purpose.
+%%# As explained in the example, the main generic macro provided to this
+%%# purpose is \toolboxMakeDef. Its call syntax is as follows:
+%%#
+%%# \toolboxMakeDef[Prefix]{Name}{ReplacementMask}
+%%#
+%%# (the argument [Prefix] is optional and by default empty).
+%%# The above command generates new macros
+%%#
+%%# \PrefixNewName
+%%# \PrefixRenewName
+%%# \PrefixProvideName
+%%# \PrefixDefName
+%%# \PrefixLetName
+%%# \PrefixName
+%%#
+%%# which in turn can be called as follows
+%%#
+%%# \PrefixNewName{something}{RememberText}
+%%# \PrefixRenewName{something}{RememberText}
+%%# \PrefixProvideName{something}{RememberText}
+%%# \PrefixDefName{something}{RememberText}
+%%# \PrefixNewName*{something}{\SomeMacro}
+%%# \PrefixRenewName*{something}{\SomeMacro}
+%%# \PrefixProvideName*{something}{\SomeMacro}
+%%# \PrefixDefName*{something}{\SomeMacro}
+%%# \PrefixLetName{\SomeMacro}{something}
+%%# \PrefixName{something}
+%%# \PrefixName*{something}
+%%#
+%%# These calls are in a sense similar to the respective commands
+%%#
+%%# \newcommand{\something}{RememberText}
+%%# \renewcommand{\something}{RememberText}
+%%# \providecommand{\something}{RememberText}
+%%# \def\something{RememberText}
+%%# \newcommand{\something}{}\let\something\SomeMacro
+%%# \renewcommand{\something}{}\let\something\SomeMacro
+%%# \@ifundefined\something{\let\something\SomeMacro}{}
+%%# \let\something\SomeMacro
+%%# \let\SomeMacro{\something}
+%%# \something
+%%# \something (but without error if \something is undefined).
+%%#
+%%# with the differences already pointed out before:
+%%# 1. The macro name actually used is not \something. Instead, it is a name
+%%#    which does not conflict with any existing macro (except one
+%%#    generated previously by another \PrefixNewName, but in this case a
+%%#    descriptive error is reported). For this reason, it is not possible to
+%%#    use this macro directly but only indirectly by the call
+%%#    \PrefixName{something} (or with \PrefixLetName).
+%%# 2. The replacement text is not `RememberText' but determined by
+%%#    ReplacementMask where every occurrence of #1 in ReplacementMask is
+%%#    replaced by RememberText (recall the examples). If you want to have the
+%%#    plain RememberText, use {#1} as ReplacementMask.
+%%#
+%%# Since toolbox 4.2 there is another slight difference: The symbol '#'
+%%# is treated as usual and not as in a macro definition.
+%%#
+%%# \toolboxMakeDef gives an error message if the commands
+%%# \Prefix... are already defined. If you intentionally want to
+%%# change a previous definition, you have to call the command
+%%#
+%%#    \toolboxFreeDef[Prefix]{Name}
+%%#
+%%# before. The latter not only lets all of the macros \Prefix... be
+%%# \undefined, but also frees all other memory internally used by the
+%%# corresponding call of \toolboxMakeDef
+%%# (note, however, that the above command does not free the
+%%# memory allocated before by calls of \PrefixNew... - to free the latter,
+%%# you have to call subsequently e.g.
+%%#
+%%#    \PrefixNewName*{...}{\undefined}
+%%#
+%%% before). There is also the command
+%%#
+%%#    \toolboxFreeDef*[Prefix]{Name}
+%%#
+%%# which acts similarly as \toolboxFreeDef but which does not undefine the
+%%# two macros \PrefixName and \PrefixLetName.
+%%#
+
+
+%%#
+%%# Fancy optional argument parsing
+%%# -------------------------------
+
+%%# This section contains macros which are convenient if you e.g. write a
+%%# package that contains macros which contain a lot of optional arguments
+%%# and flags (like "*").
+%%# Typically, to read such an optional argument or flag, you save
+%%# the next token with \futurelet and then call a macro which decides what to
+%%# do with the token read. Thus, a typical use of \futurelet looks like
+%%# 
+%%#    \def\MacroWithOptionalFlag{\futurelet\tokread\myscan}
+%%#
+%%# which will define \tokread to be the token *following* the macro
+%%# \MacroWithOptionalFlag in the token stream and then execute \myscan.
+%%# In this context, it is not very convenient that you are *forced*
+%%# to define a macro \myscan: It could be more convenient if you could just
+%%# write the *content* of \tokread (in braces) into the above definition.
+%%# You can indeed do this if you replace \futurelet by \toolboxFuturelet:
+%%#
+%%# \toolboxFuturelet\token{argument}
+%%#
+%%# The call \toolboxFuturelet\token{\command} has precisely the same effect as
+%%# \futurelet\token\command. The advantage of \toolboxFuturelet is that
+%%# instead of a single \command one may use also a sequence of commands.
+
+%%# Let us consider \MacroWithOptionalFlag as above. Assume that the user
+%%# has called this macro in the form "\MacroWithOptionalFlag*" where the
+%%# "*" is a flag which should cause your macro to do something slightly
+%%# different. On some place in your macro definition you will have recognized
+%%# (e.g. with \futurelet or \toolboxFuturelet) that a "*" is following
+%%# in the calling sequence. So you now want to execute your action
+%%# (whatever \MacroWithOptionalFlag is supposed to do).
+%%# However, if you do not take special care, after this action, TeX will
+%%# print a "*", because this is the next token on the token stream: \futurelet
+%%# does not delete any tokens. So you have to "gobble" this token away.
+%%# A rude way to do this is by using the macro \gobblenext as the last token
+%%# in you macro which can be defined by
+%%# \begin{verbatim}
+%%# \def\gobblenext#1{}\end{verbatim}
+%%# However, this has two major drawbacks:
+%%#
+%%# 1. This works for "*", but not for "{" or space tokens.
+%%#    For space tokens the situation is even worse, since TeX eats spaces
+%%#    around arguments, so sometimes space tokens might unexpectedly
+%%#    disappear.
+%%# 2. It is not possible in this way to read another argument following
+%%#    the "*": Recall that \gobblenext must be the *last* token in your
+%%#    macro expansion, i.e. you have "lost control" after this call.
+%%#
+%%# The solution to these problems is instead of calling \gobblenext to use
+%%# \toolboxGobbleNext as the last command in your call:
+%%# You can pass it an argument which describes the action that
+%%# you want to do *after* gobbling the next token ("*" in the above example)
+%%# from the token stream. Thus
+%%#
+%%# \toolboxGobbleNext{cmd}
+%%#
+%%# erases the token following that command from the token stream and
+%%# then executes cmd. This is similar to
+%%#   \def\toolboxGobbleNext#1#2{#1}
+%%# with the difference that #2 is considered as a token and that no spaces
+%%# are eaten.
+%%# The effect is that e.g. the call
+%%#
+%%# Example:
+%%#  \toolboxGobbleNext{\foo}{{arg}
+%%# is the same as \foo{arg} (the brace "{" is eaten in this example).
+
+%%# As described earlier, the commands "\futurelet" or "\toolboxFuturelet" can
+%%# be used to check for optional flags. Frequently you will only want
+%%# to test for one particular flag and decide the next action on this flag.
+%%# Of course, you can test the token found with \ifx...\f", but this has the
+%%# disadvantage that some tokens (e.g. \fi) follow your action, which might
+%%# be bad (recall that e.g. \toolboxGobbleNext must be the last command of
+%%# your action, i.e. it would in the above examples not gobble the "*" but
+%%# the "\fi" which is probably not what you want).
+%%# The simplest solution is to use the command \toolboxIfNextToken which
+%%# already has the test included. For example, to test for an optional "[",
+%%# you can simply write
+%%#
+%%# \def\MacroWithOptionalBrace{\toolboxIfNextToken[{\yes}{\no}}
+%%#
+%%# and then the call "\MacroWithOptionalBrace[...]" will expand to "\yes[...]"
+%%# while "\MacroWithOptionalBrace x" will expand to "\no x"
+%%# (note that the brace is not gobbled - if you want the latter,
+%%# use "\toolboxIfNextGobbling" described below).
+
+%%# More precisely, the calling syntax of "\toolboxIfNextToken" is
+%%#
+%%# \toolboxIfNextToken{token}{IfPart}{ElsePart}
+%%#
+%%# The semantic is the following:
+%%# If the token following this command is `token', then IfPart is executed,
+%%# otherwise ElsePart. It is explicitly admissible that `token' is a space.
+%%# To support further tests, \toolboxToken is \let to the token which follows
+%%# the command. \toolboxToken is only a temporary token, i.e.
+%%# it may also be modified by other commands of this package; in particular,
+%%# you may also freely to modify \toolboxToken.
+%%# The token \toolboxSpaceToken which is described later may be handy
+%%# in connection with this command.
+%%#
+%%# In contrast to similar LaTeX2e macros much care has been taken
+%%# that spaces are not eaten. This solves the following problem:
+%%#
+%%# Assume that you want to write a macro which should have the calling syntax
+%%# "\mymacro{arg1}" or "\mymacro{arg1}[arg2]". You will probably implement
+%%# \mymacro to read the first argument and then to look whether the next
+%%# token is a "[". If you use the LaTeX2e macro to test for "[",
+%%# then all spaces until the next non-space token would be gobbled which means
+%%# that if you would use the LaTeX2e macros for the test, then the call
+%%# "\mymacro{arg1} Text" would behave like "\mymacro{arg1}Text",
+%%# i.e. the space is `mysteriously' lost. With the "toolbox" macros this
+%%# does not happen. The `disadvantage' is that "\mymacro{arg1} [arg2]"
+%%# is not the same as "\mymacro{arg1}[arg2]" (which is reasonable IMHO).
+%%#
+%%# Example:
+%%#
+%%# \def\mycmd#1{\toolboxIfNextToken[{\ParseOpt{#1}}{\NoOpt{#1}}}
+%%#    \def\ParseOpt#1[#2]{\OptAtEnd{#1}{#2}}
+%%#
+%%# After the above definition, \mycmd{arg} executes \NoOpt{arg} while
+%%# \mycmd{arg}[optional]  executes \OptAtEnd{arg}{optional}
+%%# We point out once more that in the first call a space following
+%%# \mycmd{arg} does not vanish (as would be the case if the LaTeX 2e macros
+%%# would have been used).
+
+%%# If \toolboxIfNextToken has found the required token, it does *not*
+%%# gobble that token from the token stream. Of course, you can do this by
+%%# yourself using the earlier described macro \toolboxGobbleNext. However,
+%%# it is simpler to use
+%%#
+%%# \toolboxIfNextGobbling{token}{IfPart}{ElsePart}
+%%#
+%%# This command is analogous to \toolboxIfNextToken with the difference that
+%%# in the case that the next token is the desired token, it is gobbled before
+%%# IfPart is executed.
+%%#
+%%# Example:
+%%#
+%%# \def\myloop{\toolboxIfNextGobbling*\toolboxTokenLoop\toolboxLoop}
+%%#
+%%# This makes \myloop*... behave like \toolboxTokenLoop, and
+%%# \myloop... (without *) behave like \toolboxLoop.
+
+%%# The following macro is one which you may want to use in connection with
+%%# LaTeX 2e optional arguments:
+%%#
+%%# \toolboxIfEmpty{arg}{IfPart}{ElsePart}
+%%#
+%%# The argument is not expand; it is only used to decide whether the
+%%# {IfPart} or the {ElsePart} will be expanded.
+%%# For further tests there are more involved macros:
+%%#
+%%# \toolboxIfx{arg}\macro{IfPart}{ElsePart}
+%%#
+%%# This tests via \ifx whether \def\Macro{arg} would give the definition
+%%# of \macro.
+%%#
+%%# \toolboxIfX{arga}{argb}{IfPart}{ElsePart}
+%%#
+%%# This tests whether "arga" and "argb" are the same token sequences.
+%%# If you want to avoid the \else and \fi commands to avoid certain side
+%%# effects, you can use instead:
+%%#
+%%# \toolboxIfElse{ifcmd}{IfPart}{ElsePart}
+%%#
+%%# This is rather analogous to "ifcmd" IfPart \else ElsePart \fi
+%%# but has everything in this line already eliminated from the tokenlist
+%%# when IfPart resp. ElsePart are expanded.
+
+%%#
+%%# Loops over tokenlists and itemlists
+%%# -----------------------------------
+
+%%# \toolboxLoop{items}{action}
+%%#
+%%# This calls iteratively "action{#1}", where #1 runs over each item in the
+%%# argument items. Here, an item is either a token or a group braced by {...}.
+%%# In the latter case, the braces are lost. Spaces in items are ignored
+%%# (unless they are braced). It is admissible that \action is not a single
+%%# macro but instead a sequence of tokens.
+%%# Examples follow below.
+%%#
+%%# The counterintuitive order of arguments is explained by the fact that the
+%%# typical usage is
+%%# \expandafter\toolboxLoop\expandafter{\MacroExpandingToItems}{action}
+%%# which for swapped order of arguments could hardly be written.
+
+%%# \toolboxLoop is not reentrant i.e. "action" may not expand
+%%# to something which contains a call to \toolboxLoop. To enable such calls
+%%# anyway, the command
+%%#
+%%# \toolboxLoopName{name}{items}{\action}
+%%#
+%%# is provided which is analogous to \toolboxLoop. This is also not reentrant,
+%%# but in contrast to \toolboxLoop, calls with different `name' arguments can
+%%# be used independently of each other, i.e. in the `action' part of a
+%%# \toolboxLoop (or \toolboxLoopName) can be a call to \toolboxLoopName with
+%%# a *different* `name'.
+%%# In particular, using a counter in `name' one could easily implement
+%%# even recursive calls. In this connection, it should be noted that
+%%# `name' is expanded via \csname ... \endcsname, and so you may use
+%%# constructs like \the\namecounter there.
+
+%%# \toolboxTokenLoop{tokens}{\action}
+%%#
+%%# This is similar to \toolboxLoop: The command \action\toolboxToken
+%%# is executed iteratively where \toolboxToken runs over each token in tokens.
+%%# The important difference is that \toolboxToken is a token (instead of an
+%%# item). In particular, \toolboxToken runs through every single token
+%%# including spaces and braces.
+%%# The token \toolboxSpaceToken which is described later may be handy
+%%# in connection with this command.
+%%#
+%%# Example:
+%%#
+%%# \toolboxTokenLoop{Some text}{\kern0.1em}
+%%#
+%%# is the similar to "\kern0.1em S\kern0.1em o\kern0.1em m...", i.e. you
+%%# get wider spacing between the letters of "Some text" (I do not claim that
+%%# this is typographically a good idea).
+%%#
+%%# Note that you do not have to take special care about the space.
+%%# With \toolboxLoop, you would have to mask the space e.g. with
+%%#
+%%# \toolboxLoop{Some{ }text}{\kern0.1em}  or
+%%# \toolboxLoop{Some\toolboxSpace text}{\kern0.1em}
+%%#
+%%# In contrast, \toolboxTokenLoop would behave differently here:
+%%#
+%%# \toolboxTokenLoop{Some{ }text}{\kern0.1em}
+%%#
+%%# would produce \kern0.1em S...\kern0.1em{\kern0.1em <space>\kern0.1em}...
+%%# because the braces are simply considered as tokens.
+
+%%# \toolboxTokenLoop is not reentrant. Analogously to \toolboxLoopName,
+%%# independent versions can be generated by
+%%#
+%%# \toolboxTokenName{name}{tokens}{\action}
+
+%%#
+%%# Controlled expansion
+%%# --------------------
+
+%%# There are some occasions when you want more control over the expansion.
+%%# E.g. you might want to concatenate the contents of two macros to a
+%%# further macro or you want to expand a macro by one level but no full
+%%# expansion. Usually you can get this effects with \expandafter, but if
+%%# you expand several concatenated tokens in this way you either have to
+%%# write a lot of \expandafter's or you have to define subsidiary macros
+%%# that help you to \expandafter certain parts of macros. The macros in
+%%# this section allow you to do this in the most generic way that I could
+%%# implement.
+
+%%# \toolboxDef\macrotodefine{argumentlist}
+%%#
+%%# This call is similar to
+%%#    \def\macrotodefine{argumentlist}
+%%# with two important differences:
+%%#
+%%# For \toolboxDef, the argumentlist is expanded precisely by one level.
+%%# argumentlist may not contain macros with parameters, and spaces on the
+%%# highest level are ignored. If you want to force a space on a particular
+%%# place, use the macro \toolboxSpace at this place
+%%# (which is described later). Contrary to the usual \def, the symbol # is
+%%# treated as a usual symbol.
+%%#
+%%# Example of usage:
+%%#    \toolboxDef\chain{\chain\toolboxSpace\after}
+%%# This modifies the macro \chain such that a space and the content of the
+%%# macro \after is appended at the end.
+
+%%# \toolboxAppend\macrotodefine{arglist}
+%%#
+%%# This is equivalent to \toolboxDef\macrotodefine{\macrotodefine arglist}
+%%#
+
+%%# \toolboxSurround{ContentBefore}{ContentAfter}\macro
+%%#
+%%# This redefines \macro such that ContentBefore is put at the beginning
+%%# and ContentAfter after the definition of \macro. So this is equivalent to
+%%# \def\macro{ContentBefore * ContentAfter}
+%%# where * is the old content of \macro. It is required that \macro is a
+%%# usual macro without any arguments. If you want to patch more complicated
+%%# macros, use the patch.doc package instead.
+%%# The order of the arguments may appear strange, but it is convenient if
+%%# ContentBefore or ContentAfter are macros which should be expanded with
+%%# \expandafter.
+
+%%# There is some subsidiary macro used in the implementation of the above
+%%# macros which might be useful also in some other situations:
+%%#
+%%# \toolboxTokDef{argumentlist}\macrotodefine
+%%#
+%%# This call is similar to
+%%#    \def\macrotodefine{argumentlist}
+%%# with the difference that the symbol # is stored as such.
+%%# The order of the arguments has been swapped in order to simplify the
+%%# application of \expandafter to the argumentlist.
+
+%%#
+%%# Searching, splitting, and replacing
+%%# ----------------------------------
+
+%%# \toolboxSplitAt{argument}{search}{\beforestring}{\afterstring}
+%%#
+%%# Here, \beforestring and \afterstring are arbitrary macro names,
+%%# and search and argument are any sequences of tokens (which are in
+%%# the following considered as `strings').
+%%#
+%%# This call scans the string `argument' for the first occurrence of `search'.
+%%# The macros \beforestring and \afterstring are defined correspondingly
+%%# such that \beforestring expands to the part before the first occurrence,
+%%# and \afterstring to the part following the first occurrence.
+%%# If `search' does not occur in `argument', \beforestring is defined to
+%%# `argument', and \afterstring is \let \undefined.
+%%#
+%%# If \beforestring or \afterstring had already been defined before the
+%%# call, the previous definition is tacitly overridden.
+%%# It is explicitly allowed that \beforestring and \afterstring are the
+%%# same names. In this case, the result has the meaning of \afterstring.
+%%#
+%%# It is guaranteed that braces {...} are *not* lost in `argument'.
+%%# However, `search' may not contain any braces, and `argument' may contain
+%%# only matching pairs of braces. Moreover, occurrences of `search' within a
+%%# pair of braces in `argument' are not recognized.
+%%#
+%%# (The order of the arguments has been chosen in order to simplify the
+%%# use of \expandafter).
+%%#
+%%# There are some restrictions for the strings in search. For example,
+%%# the symbol '#' is not allowed.
+%%#
+%%# In the above call, the arguments may not run over several paragraphs.
+%%# If you want the latter, you have to use the alternative call
+%%#
+%%# \toolboxSplitAt*{argument}{search}{\beforestring}{\afterstring}
+%%#
+%%# Example of usage:
+%%#
+%%# \def\examplemacro#1{\toolboxSplitAt{#1}{@}\testme\testme
+%%#   \ifx\testme\undefined
+%%#      ... (do this when #1 contains no `@' token)
+%%#   \fi}
+%%#
+
+%%# \toolboxMakeSplit{search}{command}
+%%#
+%%# If \toolboxSplitAt should be used several times with the same search
+%%# string, it is much more effective to use the above call: This call
+%%# defines a new macro \command (the name is determined by the second argument
+%%# of \toolboxMakeSplit) which can be called in the form
+%%#
+%%#    \command{argument}{\beforestring}{\afterstring}
+%%#
+%%# and which has the analogous meaning as \toolboxSplitAt (the argument
+%%# {search} is implicitly fixed and taken from the call of
+%%# \toolboxMakeSplit).
+%%# It is explicitly admissible that the above macro \toolboxMakeSplit is
+%%# used with an already existing command name. In this case, the previous
+%%# definition of \command is tacitly overridden.
+%%#
+%%# The command created by \toolboxMakeSplit does not accept arguments which
+%%# run over several paragraphs. If you want the latter, you have to create
+%%# this command by the alternative call
+%%#
+%%# \toolboxMakeSplit*{search}{command}
+
+%%#
+%%# The command
+%%#    \toolboxFreeSplit{command}
+%%# frees the memory used by a previous \toolboxMakeSplit (and lets \command
+%%# again be undefined).
+
+%%# The command
+%%#    \toolboxReplace{search}{replace}\macro
+%%# replaces in \macro all occurences of {search} by {replace}.
+%%# The same matches are found as in \toolboxSplitAt.
+%%# If you need to search for the same text several times, it is faster
+%%# to use the command
+%%#    \toolboxReplaceSplit{replace}\SplitCmd\macro
+%%# where \SplitCmd is a command previously generated with \toolboxMakeSplit*
+%%# according to your search string. (You could also use \toolboxMakeSplit
+%%# to generate \SplitCmd, but then \macro should not contain any \par's).
+
+%%#
+%%# Redefinition of macros
+%%# ----------------------
+
+%%# \toolboxMakeHarmless{\macro}
+%%#
+%%# The above call redefines \macro such that it expands to an ASCII text
+%%# containing the previous definition of \macro (i.e. the catcodes of \macro
+%%# are changed).
+
+%%# \toolboxDropBrace\variable
+%%#
+%%# drops possible outer braces in \variable. More precisely,
+%%# if \variable expands to {content}, then \variable is redefined to
+%%# content (without braces). Otherwise, nothing happens.
+
+%%#
+%%# \toolboxIf\comparison{DefinitionCommand}{\macro}...
+%%#
+%%# The above command allows conditional definitions.
+%%# Here, {DefinitionCommand} is either \def, {\long\def}, \let, or some
+%%# similar command like the LaTeX \newcommand. If the test
+%%# \ifx\comparison\macro evaluates positive, then \macro is defined
+%%# correspondingly. Otherwise, \macro is not changed.
+%%#
+%%# Examples:
+%%#
+%%# \toolboxIf\undefined\def\macro{....}
+%%# \toolboxIf\undefined\let\macro...
+%%# \toolboxIf\undefined{\long\def}\macro{....}
+%%# \toolboxIf\undefined\newcommand{\macro}{....}
+%%#
+%%# are similar to \def\macro{...} resp. \let\macro... resp.
+%%# \long\def\macro{...} resp. \newcommand{\macro}{...} with the difference
+%%# that \macro is not changed if it was already defined.
+%%# In this sense, \toolboxIf is a more flexible variant of \providecommand.
+%%#
+
+%%# \toolboxNewiftrue{name} or \toolboxNewiffalse{name}
+%%#
+%%# If the command \ifname was already introduced with \newif, then
+%%# nothing happens. Otherwise \ifname is introduced similarly to
+%%# \newif\ifname and set to `true' respectively `false'.
+%%# In contrast to the corresponding command in TeX or LaTeX 2.09, this macro
+%%# is not \outer!
+
+%%# \toolboxNewifTrue{name} or \toolboxNewifFalse{name}
+%%#
+%%# are similar to \toolboxNewiftrue{name} and \toolboxNewiffalse{name},
+%%# respectively, with the difference that \ifname is set unconditionally
+%%# to `true' respectively `false'.
+
+%%#
+%%# Concatenated macro names
+%%# ------------------------
+
+%%# \toolboxLet\variable{macroname}
+%%#
+%%# The above command is analogous to \let\variable\macroname with the
+%%# difference that macroname can also contain other tokens like numbers
+%%# (it is obtained via \csname). Some converse to this command is
+%%#
+%%# \toolboxWithNr {number}\cmd{macro}
+%%#
+%%# which translates into \cmd\macronumber (here, `macro' and `number'
+%%# are just concatenated and evaluated via \csname).
+%%# Examples:
+%%#   \toolboxWithNr 1\let{name}\toolboxEmpty
+%%#        This is the same as \let\name1\toolboxEmpty
+%%#            (but such that \name1 is considered as a name, not as \name 1)
+%%#   \toolboxWithNr {10}\def{name}{Foo}
+%%#        This corresponds analogously to \def\name10{Foo}.
+%%#   \toolboxLet \mymacro{name\the\mycount}
+%%#        This is similar to \let\mymacro\namexx where xx is the content
+%%#        of the counter \mycount.
+
+%%#
+%%# Various
+%%# -------
+
+%%# The following macros have equivalents in most formats (like LaTeX2e).
+%%# However, we do not want to rely too much on these formats, so we provide
+%%# our own definitions.
+%%# The macro
+%%#    \toolboxEmpty
+%%# expands to nothing (usually, this is the same as \empty).
+%%# Similarly, the macro
+%%#    \toolboxSpace
+%%# expands to a space symbol (usually, this is the same as \space).
+%%# The token
+%%#    \toolboxSpaceToken
+%%# is \let a space token (usually, this is the same as \@sptoken).
+%%# This token is convenient in tests of tokens
+%%# (because it is hard to get a space there which is not eaten by the TeX
+%%#  parser, although sometimes also constructions like
+%%#  \expandafter\ifx\toolboxSpace\token can be used).
+%%# Also the macros
+%%#    \toolboxFirstOfTwo
+%%#    \toolboxSecondOfTwo
+%%# are provided which read two arguments and return only the first
+%%# respectively second argument (usually, this is the same as
+%%# \@firstoftwo respectively \@secondoftwo). Similarly,
+%%#    \toolboxGobbleArg{argument}
+%%# just reads its argument and expands to nothing.
+
+
+
+%  This is the end of the ascii documentation
+%</asciidocu>
+%\fi\catcode\#6\relax
+%
+% \iffalse
+%<*metainfo>
+% \fi
+
+% \def\basename{toolbox}
+
+%% \CharacterTable
+%%  {Upper-case    \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z
+%%   Lower-case    \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z
+%%   Digits        \0\1\2\3\4\5\6\7\8\9
+%%   Exclamation   \!     Double quote  \"     Hash (number) \#
+%%   Dollar        \$     Percent       \%     Ampersand     \&
+%%   Acute accent  \'     Left paren    \(     Right paren   \)
+%%   Asterisk      \*     Plus          \+     Comma         \,
+%%   Minus         \-     Point         \.     Solidus       \/
+%%   Colon         \:     Semicolon     \;     Less than     \<
+%%   Equals        \=     Greater than  \>     Question mark \?
+%%   Commercial at \@     Left bracket  \[     Backslash     \\
+%%   Right bracket \]     Circumflex    \^     Underscore    \_
+%%   Grave accent  \`     Left brace    \{     Vertical bar  \|
+%%   Right brace   \}     Tilde         \~}
+
+% \CheckSum{736}
+
+% \iffalse
+%   \RecordChanges
+% \fi
+% \def\mypar{}
+% \def\ChangesTab{}\let\orichanges\changes
+% \def\changes#1#2#3{\orichanges{#1}{#2}{#3}
+%   \expandafter\def\expandafter\ChangesTab\expandafter{\ChangesTab
+%   \item[v#1 {\mdseries(\emph{#2})}] {#3.}}}
+% \newcommand{\cmdcite}[1]{\texttt{\textbackslash#1}}
+% \newcommand{\bracemeta}[1]{\texttt{\{}\meta{#1}\texttt{\}}}
+% \newcommand{\cmdmeta}{\textbackslash\meta}
+
+% \changes{5.1}{2004/04/29}{Added \cmdcite{toolboxReplace},
+%    \cmdcite{toolboxReplaceSplit}. Some corrections in the documentation.
+%    Added some forgotten \cmdcite{long}'s in the code.}
+% \changes{4.4}{2003/10/07}{Added \cmdcite{toolboxIfEmpty},
+%    \cmdcite{toolboxIfx}, \cmdcite{toolboxIfX},  \cmdcite{toolboxIfElse}.
+%    Some corrections in the documentation}
+% \changes{4.3}{2002/09/27}{Major enhancements in documentation: Added lots
+%    of examples and explanation about typical applications.
+%    Bugfix in \cmdcite{toolboxMakeDef}:
+%    \cmdmeta{Prefix}\texttt{Provide}\meta{Name} now behaves like
+%    \cmdcite{providecommand} as documented. The old meaning is now called
+%    \cmdmeta{Prefix}\texttt{Def}\meta{Name}.
+%    Introduced \cmdcite{toolboxGobbleArg}}
+% \changes{4.2}{2001/09/26}{Treating \texttt{\#} properly now also in
+%    \cmdcite{toolboxMakeDef}}
+% \changes{4.1}{2001/09/24}{Took more care of treating \texttt{\#} properly
+%    when this symbol occurs in arguments of certain macros (the treatment is
+%    not completely downward compatible; for this reason the major release
+%    number has been changed). For this reason,
+%    also the new macro \cmdcite{toolboxTokDef} is provided. I thank
+%    David Kastrup \texttt{<David.Kastrup@neuroinformatik.ruhr-uni-bochum.de>}
+%    for pointing out this problem (and a solution) to me}
+% \changes{3.3}{2001/08/19}{Eliminated a bug in \cmdcite{toolboxMakeSplit*}}
+% \changes{3.2}{2001/05/08}{Eliminated a serious bug in \cmdcite{toolboxIf}.
+%    Due to this bugfix, the usage of \cmdcite{toolboxIf} had to be slightly
+%    restricted}
+% \changes{3.1}{2001/05/06}{Major advantage: \cmdcite{toolboxMakeDef}
+%    implemented.\mypar
+%    Reimplemented \cmdcite{newif} (apparently by mistake, this had been
+%    declared as \cmdcite{outer} in \TeX\ and \LaTeX 2.09 which caused an
+%    error during loading of \texttt{toolbox.sty}).
+%    For this reason, also \cmdcite{toolboxNewifTrue} and
+%    \cmdcite{toolboxNewifFalse} were introduced}
+% \changes{2.1}{2001/04/30}{Introduced \cmdcite{toolboxIf},
+%    \cmdcite{toolboxAppend}, and \cmdcite{toolboxSurround}}
+% \changes{2.0}{2001/04/08}{Many major enhancements and new tools:
+%    Added section (and corresponding macros)
+%    for fancy optional arguments. Made \cmdcite{toolboxLoop} semi-reentrant by
+%    introducing \cmdcite{toolboxLoopName}.
+%    Added \cmdcite{toolboxTokenLoop} and friends.
+%    Added \cmdcite{toolboxSpaceToken}.
+%    Made many macros \cmdcite{long} and added \cmdcite{long} versions
+%    of \cmdcite{toolboxSplitAt} and \cmdcite{toolboxMakeSplit}}
+% \changes{1.0}{2001/03/29}{First release}
+%
+% \iffalse
+%
+% The following part is the code needed to compile the documentation.
+% We do some trickery here, because we want that this file here could be used
+% for *both*: Compiling the documentation *and* as `toolbox.sty'
+% (if really required).
+% Everything between the lines %<*driver> and %</driver>
+% goes to the file `toolbox.tex'.
+%
+% \fi
+\ifcat @a% If this test is positive, then `@' has letter catcode which means
+%          that this file is loaded as a style file (or as described in the
+%          install section of the documentation).
+\def\TemporaryDummy{}
+\else\long\def\TemporaryDummy{%
+%
+%
+% \iffalse
+%</metainfo>
+%<*driver>
+\documentclass{ltxdoc}
+\OnlyDescription%% Comment this out, or
+%%\AlsoImplementation%% uncomment this line, if you want to see the source.
+
+%% If you want an index, uncomment one of the following lines.
+%% After running latex a first time, you have to use
+%%      makeindex -s gind.ist toolbox
+%% Then run latex again.
+%%\CodelineIndex% comment this out if you want an index referring to codelines
+%%\PageIndex% comment this out if you want an index referring to pages
+%%\OldMakeindex% uncomment this line, if your MakeIndex is pre-v2.9
+
+\setlength\hfuzz{15pt}
+\hbadness=7000
+\begin{document}
+\DocInput{toolbox.dtx}
+\end{document}
+%</driver>
+%<*metainfo>
+% \fi
+}
+\fi\TemporaryDummy\let\TemporaryDummy\undefined
+%
+% \iffalse
+%          Personal macros used for the doc utility:
+% \fi
+% \MakeShortVerb{"}
+% \newcommand{\filecite}[1]{\texttt{#1}}
+% \newcommand{\nocomment}{}
+% \newcommand{\myspace}{\texttt{\textvisiblespace}}
+% \parindent0pt
+
+% \title{The \texttt{toolbox} package\thanks
+%   {This  file has version number \fileversion{}, last revised \filedate.}}
+% \author{Martin V\"ath\relax
+%\thanks{\texttt{vaeth@mathematik.uni-wuerzburg.de}}
+%{}\thanks{The author thanks
+%David Kastrup \texttt{<David.Kastrup@neuroinformatik.ruhr-uni-bochum.de>}.
+%}}
+% \date{\docdate}
+% \maketitle\sloppy
+
+% \begin{abstract}
+%  The \TeX\ programmer's toolbox; enhanced version.
+%  This package provides some macros which are convenient for writing
+%  indices, glossaries, or other macros. It contains macros which support
+%  \begin{itemize}
+%    \item implicit macros -- a useful supplement to \cmdcite{index} or
+%          \texttt{varindex} for writing glossaries or indices.
+%    \item fancy optional arguments
+%    \item loops over tokenlists and itemlists
+%    \item searching, splitting, and replacing
+%    \item controlled expansion
+%    \item redefinition of macros
+%    \item concatenated macro names
+%  \end{itemize}
+% \end{abstract}
+
+% You may copy this package freely, as long as you distribute only unmodified
+% and complete versions.
+
+% \tableofcontents
+
+% \section{Changes}
+%
+% \begin{description}
+%    \def\mypar{\par}\ChangesTab
+% \end{description}
+%
+
+% \section{Installation}
+
+% This package was tested with \TeX, \LaTeX 2.09, and \LaTeXe, and it
+% should actually run with all other \TeX\ formats.
+
+% To use \filecite{toolbox}, you have to put the file \filecite{toolbox.sty}
+% in a path where \TeX\ looks for its input files. The \TeX\ documents using
+% \filecite{toolbox} need the following modifications in their header:
+%
+% \begin{itemize}
+% \item If you use \LaTeXe, put in the preamble the command
+%   \begin{verbatim}
+%     \usepackage{toolbox}\end{verbatim}
+%
+% \item If you use \LaTeX 2.09, use \filecite{toolbox} as a style option, e.g.\
+%   \begin{verbatim}
+%     \documentstyle[toolbox]{article}\end{verbatim}
+%    or
+%   \begin{verbatim}
+%     \documentstyle[toolbox,12pt]{article}\end{verbatim}
+%
+% \item If you use some other (non-\LaTeX) format, you will probably have to
+%    insert a line like
+% \begin{verbatim}
+% \catcode`\@=11\input toolbox.sty\catcode`\@=12\relax\end{verbatim}
+%
+% \end{itemize}
+%
+% The only \LaTeX-specific commands used in \filecite{toolbox.sty} are:
+%
+% \begin{itemize}
+% \item "\newcommand" (used only in the form "\newcommand{"\meta{command}"}{}"
+%       to ensure that \meta{command} was not defined before)
+% \item "\ProvidesPackage"
+% \item "\typeout"
+% \end{itemize}
+% The above commands are used only if they are defined.
+
+% \section{Description of the macros}
+%
+% General remark: Many macros could appear in several sections.
+% For example, "\toolboxMakeDef" and "\toolboxSourround" might be considered
+% as macros which support redefinitions of macros. However, we put them
+% in different sections which perhaps explain better their nature.
+%
+% \subsection{Implicit macro definitions}
+%
+% What we mean by implicit macro definitions is probably best explained by
+% the following examples which show the intended usage:\par\bigskip
+%
+% (In the following examples, we always refer to the "\index" command. Note
+% that it may be more convenient to use for indices the \filecite{varindex}
+% package in addition -- the documentation of \filecite{varindex}
+% (release 2.3 or newer) gives additional hints and examples how these two
+% (essentially independent) approaches can be combined in practice).
+% \par\bigskip
+%
+% Assume that you want to write an index for a book which has rather
+% long and complicated "\index" entries. The first idea that one might have in
+% this connection is to put the various "\index" commands at the beginning of
+% the document into several macros (one for each "\index" entry), and to use
+% just these macros in the main text. For example, one might want to write
+% near the beginning of the document commands like
+% \begin{verbatim}
+%   \newcommand{\Start}{\index{finish or end}}
+%   \newcommand{\End}{\index{finish or end}}\end{verbatim}
+% and then to use in the main text "\Start" and "\End" whenever a reference
+% in the corresponding index to the current place is desired.
+% However, this has two major disadvantages:
+% \begin{enumerate}
+% \item It is easy to forget that "\End" writes an index entry.
+%       So the macro "\End" in the main text might be very confusing.
+% \item You cannot choose short and intuitive macro names for common phrases,
+%       because they are usually already reserved by \TeX, \LaTeX, or some
+%       packages. For example, "\end" could not be used.
+% \end{enumerate}
+% To avoid these problems, one may be very disciplinary and call the
+% involved macros systematically e.g.\ "\GlossaryStart" "\GlossaryEnd" etc.
+% However, this produces terrible long and unreadable macro names in the main
+% text.\par\bigskip
+% The implicit macro definitions of \filecite{toolbox} provide a more
+% convenient solution.
+% The idea is that you do not use the corresponding macros directly but only
+% implicitly by a call of other macros where your ``macro name'' is just an
+% argument.\par
+% Moreover, \filecite{toolbox} assists you in writing the corresponding
+% definitions.
+% For example, if you know that you want a set of macros which all expand
+% into something of the form "\index{...}", you can give a ``mask'' which
+% contains this form, and you only have to fill in the changing content
+% (similarly as for usual \TeX\ macros with arguments, but the level of
+% abstraction is one step higher).
+% For the above task, you might use the command:
+% \begin{verbatim}
+%    \toolboxMakeDef{Glossary}{\index{#1}}\end{verbatim}
+%
+% The argument "Glossary" serves to distinguish independent definitions
+% (this will become clear later). Its effect visible now is that it
+% determines the name of the following macros which you can use after
+% the above call:
+% \begin{verbatim}
+%    \NewGlossary{start-1}{start}
+%    \NewGlossary{start-2}{start or beginning}
+%    \NewGlossary{end}{finish or end}\end{verbatim}
+%
+% These command are now similar to the "\newcommand" definitions explained
+% above. However, there is no name collision with the \TeX-internal command
+% "\end". Of course, this means that you cannot just write "\end" in the main
+% text to get the desired index entry. Instead, you have to write the more
+% intuitive commands
+% \begin{verbatim}
+%    \Glossary{start-1}
+%    \Glossary{start-2}
+%    \Glossary{end}\end{verbatim}
+% (again, the name "\Glossary" stems from our first call of "\toolboxMakeDef").
+% Note that e.g.\ "\Glossary{start-1}" expands not only to "start" but
+% actually to "\index{start}" (because of our first call of
+% "\toolboxMakeDef").\par
+% Note also that you can use symbols like ``-'' or numbers which are
+% usually not allowed in \TeX\ macro names.
+%
+% Of course, similarly as for "\newcommand", you can also do other things with
+% the macros. For example,
+% \begin{verbatim}
+%    \LetGlossary\tempname{end}
+%    \NewGlossary*{finish}\tempname\end{verbatim}
+%
+% will first define "\tempname" to expand to the same text as "\Glossary{end}",
+% and then defines a new entry "\Glossary{finish}" to expand to the same text
+% as "\tempname". Hence, the above two lines make the calls "\Glossary{end}"
+% and "\Glossary{finish}" equivalent.
+%
+% At the end of your list of "\NewGlossary" commands, you might want to put
+% \begin{verbatim}
+%    \toolboxFreeDef*{Glossary}\end{verbatim}
+%
+% The purpose of this command is that "\NewGlossary" cannot be used anymore
+% (unless, of course, you define it again). So you cannot unintentionally
+% add new entries to your glossary list (but you still can use "\Glossary{...}"
+% to reference to the already produced entries).
+% Moreover, the above command frees some memory which was needed for
+% "\NewGlossary" to work.
+%
+% If you additionally want to free the memory used by "\Glossary", you can use
+% \begin{verbatim}
+%    \toolboxFreeDef{Glossary}\end{verbatim}
+%
+% (without the "*"). This may be necessary, if you want to call again e.g.
+% \begin{verbatim}
+%    \toolboxMakeDef{Glossary}{\emph{#1}\index{#1}}\end{verbatim}
+%
+% (if you have not freed the memory for "\Glossary" before this repeated call,
+% \TeX\ will complain that "\Glossary" is already defined).\par\smallskip
+%
+% Of course, it is possible to call "\toolboxMakeDef" with several different
+% names, for example, for "\Glossary", "\SymbolList" etc. Another application
+% might be to use a different command to mark e.g.\ the main occurrence of
+% some index entry or to output additionally the entry into the running text.
+% We do this in the following example which simultaneously
+% demonstrates that the names can also be constructed in another way:
+% \begin{verbatim}
+%   \toolboxMakeDef[Ind]{}{\index{#1}}
+%   \toolboxMakeDef[Ind]{Main}{\index{#1|textbf}}
+%   \toolboxMakeDef{OutInd}{#1}
+%
+%   \IndNew{A}{A is a letter}
+%   \IndNewMain{A}{A is a letter}
+%   \NewOutInd{A}{\textbf{The letter A}\Ind{A}}\end{verbatim}
+% After the above commands, you can use "\Ind{A}", "\IndMain{A}", and
+% "\OutInd{A}" to produce the corresponding "\index" entry, the ``main''
+% "\index" entry (with a fat page number), and the text \textbf{The letter A}
+% with an additional entry into the index, respectively.
+% Of course, it might usually be more convenient to define the "\Ind" and
+% "\IndMain" entries simultaneously, e.g.\ by the commands
+% \begin{verbatim}
+%    \toolboxMakeDef[Ind]{}{#1}
+%    \toolboxMakeDef[Ind]{Main}{#1}
+%    \newcommand{\NewStandardInd}[2]{%
+%       \IndNew{#1}{\index{#2}}%
+%       \IndNewMain{#1}{\index{#2|textbf}}}
+%
+%    \NewStandardInd{A}{A is a letter}\end{verbatim}
+% This approach has the additional advantage that you can define exceptional
+% cases ``by hand'' (e.g.\ if you want that for certain ``main'' index
+% entries the page number is printed with "\textsl" instead of "\textbf").
+% \bigskip
+%
+% Since the motivation for implicit definitions now is hopefully clear,
+% let us now describe in detail which commands are provided by
+% \filecite{toolbox} for this purpose.
+% As explained in the example, the main generic macro provided to this
+% purpose is \DescribeMacro{\toolboxMakeDef}"\toolboxMakeDef".
+% Its call syntax is as follows:
+% \begin{quote}
+% "\toolboxMakeDef["\meta{Prefix}"]"\bracemeta{Name}\relax
+%\bracemeta{Replacement mask}
+% \end{quote}
+% (the argument "["\meta{Prefix}"]" is optional and by default empty).
+% The above command generates new macros
+%
+% \begin{quote}
+% \cmdmeta{Prefix}"New"\meta{Name}\\
+% \cmdmeta{Prefix}"Renew"\meta{Name}\\
+% \cmdmeta{Prefix}"Provide"\meta{Name}\\
+% \cmdmeta{Prefix}"Def"\meta{Name}\\
+% \cmdmeta{Prefix}"Let"\meta{Name}\\
+% \cmdmeta{Prefix}\meta{Name}
+% \end{quote}
+% which in turn can be called as follows:
+% \begin{quote}
+% \cmdmeta{Prefix}"New"\meta{Name}\bracemeta{something}\relax
+%\bracemeta{text to remember}\\
+% \cmdmeta{Prefix}"Renew"\meta{Name}\bracemeta{something}\relax
+%\bracemeta{text to remember}\\
+% \cmdmeta{Prefix}"Provide"\meta{Name}\bracemeta{something}\relax
+%\bracemeta{text to remember}\\
+% \cmdmeta{Prefix}"Def"\meta{Name}\bracemeta{something}\relax
+%\bracemeta{text to remember}\\
+% \cmdmeta{Prefix}"New"\meta{Name}"*"\bracemeta{something}\relax
+%{\cmdmeta{SomeMacro}}\\
+% \cmdmeta{Prefix}"Renew"\meta{Name}"*"\bracemeta{something}\relax
+%{\cmdmeta{SomeMacro}}\\
+% \cmdmeta{Prefix}"Provide"\meta{Name}"*"\bracemeta{something}\relax
+%{\cmdmeta{SomeMacro}}\\
+% \cmdmeta{Prefix}"Def"\meta{Name}"*"\bracemeta{something}\relax
+%{\cmdmeta{SomeMacro}}\\
+% \cmdmeta{Prefix}"Let"\meta{Name}{\cmdmeta{SomeMacro}}\bracemeta{something}\\
+% \cmdmeta{Prefix}\meta{Name}\bracemeta{something}\\
+% \cmdmeta{Prefix}\meta{Name}"*"\bracemeta{something}
+% \end{quote}
+% These calls are in a sense similar to the respective commands
+% \begin{quote}
+% "\newcommand{"\cmdmeta{something}"}"\bracemeta{text to remember}\\
+% "\renewcommand{"\cmdmeta{something}"}"\bracemeta{text to remember}\\
+% "\providecommand{"\cmdmeta{something}"}"\bracemeta{text to remember}\\
+% "\def"\cmdmeta{something}\bracemeta{text to remember}\\
+% "\newcommand{"\cmdmeta{something}"}{}"\relax
+%"\let"\cmdmeta{something}\cmdmeta{SomeMacro}\\
+% "\renewcommand{"\cmdmeta{something}"}{}"\relax
+%"\let"\cmdmeta{something}\cmdmeta{SomeMacro}\\
+% "\@ifundefined"\bracemeta{something}"{\let"\relax
+%\cmdmeta{something}\cmdmeta{SomeMacro}"}{}"\\
+% "\let"\cmdmeta{something}\cmdmeta{SomeMacro}\\
+% "\let"\cmdmeta{SomeMacro}{\cmdmeta{something}}\\
+% \cmdmeta{something}\\
+% \cmdmeta{something} (but without error if \cmdmeta{something} is undefined)
+% \end{quote}
+% with the differences already pointed out before:
+% \begin{enumerate}
+% \item The macro name actually used is not \cmdmeta{something}.
+%   Instead, it is a name which does not conflict with any existing macro
+%   (except one generated previously by another \cmdmeta{Prefix}New\meta{Name},
+%   but in this case a descriptive error is reported).\par
+%   For this reason, it is not possible to use this macro directly but only
+%   indirectly by the call \cmdmeta{Prefix}\meta{Name}\bracemeta{something}
+%   (or with \cmdmeta{Prefix}Let\meta{Name}).
+% \item The replacement text is not \meta{text to remember} but determined by
+%   \meta{Replacement Mask} where every occurrence of "#1" in
+%   \meta{Replacement Mask} is replaced by \meta{text to remember}
+%   (recall the examples). If you want to have the plain
+%   \meta{text to remember}, use "{#1}" as \meta{Replacement Mask}.
+% \end{enumerate}
+% Since \filecite{toolbox~4.2} there is another slight difference:
+% The symbol "#" is treated as usual and not as in a macro definition.\par
+%
+% "\toolboxMakeDef" gives an error message if the commands
+% \cmdmeta{Prefix}"..." are already defined. If you intentionally want to
+% change a previous definition, you have to call the command
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxFreeDef}
+% "\toolboxFreeDef["\meta{Prefix}"]"\bracemeta{Name}
+% \end{quote}
+% before. The latter not only lets all of the macros \cmdmeta{Prefix}"..." be
+% "\undefined", but also frees all other memory internally used by the
+% corresponding call of "\toolboxMakeDef"
+% (note, however, that the above command does not free the
+% memory allocated before by calls of \cmdmeta{Prefix}"New..." -- to free the
+% latter, you have to call subsequently e.g.
+% \begin{quote}
+% \cmdmeta{Prefix}"New"\meta{Name}"*{"$\ldots$"}{\undefined}"
+% \end{quote}
+% before). There is also the command
+% \begin{quote}
+% "\toolboxFreeDef*["\meta{Prefix}"]"\bracemeta{Name}
+% \end{quote}
+% which acts similarly as "\toolboxFreeDef" but which does not undefine the
+% two macros \cmdmeta{Prefix}\meta{Name} and \cmdmeta{Prefix}"Let"\meta{Name}.
+%
+
+% \subsection{Fancy optional argument parsing}
+%
+% This section contains macros which are convenient if you e.g.\ write a
+% package that contains macros which contain a lot of optional arguments
+% and flags (like "*").
+% Typically, to read such an optional argument or flag, you save
+% the next token with "\futurelet" and then call a macro which decides what to
+% do with the token read. Thus, a typical use of "\futurelet" looks like
+% \begin{verbatim}
+% \def\MacroWithOptionalFlag{\futurelet\tokread\myscan}\end{verbatim}
+% which will define "\tokread" to be the token \emph{following} the macro
+% "\MacroWithOptionalFlag" in the token stream and then execute "\myscan".
+% In this context, it is not very convenient that you
+% are \emph{forced} to define a macro "\myscan": It could be more convenient
+% if you could just write the \emph{content} of "\tokread" (in braces) into
+% the above definition. You can indeed do this if you replace "\futurelet"
+% by \DescribeMacro{\toolboxFuturelet}"\toolboxFuturelet":
+%
+% \begin{quote}
+%   "\toolboxFuturelet\token"\bracemeta{argument}
+% \end{quote}
+%
+% The call "\toolboxFuturelet\token{\command}" has precisely the same
+% effect as "\futurelet\token\command". The advantage of "\toolboxFuturelet"
+% is that instead of a single "\command" one may use also a sequence of
+% commands.\par
+
+% Let us consider "\MacroWithOptionalFlag" as above. Assume that the user
+% has called this macro in the form "\MacroWithOptionalFlag*" where the
+% "*" is a flag which should cause your macro to do something slightly
+% different. On some place in your macro definition you will have recognized
+% (e.g.\ with "\futurelet" or "\toolboxFuturelet") that a "*" is following
+% in the calling sequence. So you now want to execute your action
+% (whatever "\MacroWithOptionalFlag" is supposed to do).
+% However, if you do not take special care, after this action, \TeX\ will
+% print a "*", because this is the next token on the token stream: "\futurelet"
+% does not delete any tokens. So you have to ``gobble'' this token away.
+% A rude way to do this is by using the macro "\gobblenext" as the last token
+% in you macro which can be defined by
+% \begin{verbatim}
+% \def\gobblenext#1{}\end{verbatim}
+% However, this has two major drawbacks:
+% \begin{enumerate}
+% \item This works for "*", but not for "{" or space tokens.
+% For space tokens the situation is even worse, since \TeX\ eats spaces around
+% arguments, so sometimes space tokens might unexpectedly disappear.
+% \item It is not possible in this way to \emph{read} another argument
+% following the "*": Recall that "\gobblenext" must be the \emph{last} token
+% in your macro expansion, i.e.\ you have ``lost control'' after this call.
+% \end{enumerate}
+% The solution to these problems is instead of calling "\gobblenext" to use
+% \DescribeMacro{\toolboxGobbleNext}"\toolboxGobbleNext" as the last command
+% in your call: You can pass it an argument which describes the action that
+% you want to do \emph{after} gobbling the next token
+% ("*" in the above example) from the token stream. Thus
+% \begin{quote}
+%  "\toolboxGobbleNext"\bracemeta{cmd}
+% \end{quote}
+% erases the token following that command from the token stream and
+% then executes \meta{cmd}. This is similar to
+% \begin{verbatim}
+%   \def\toolboxGobbleNext#1#2{#1}\end{verbatim}
+% with the difference that "#2" is considered as a token and that no spaces
+% are eaten.\par
+% The effect is that e.g.\ the call
+% \begin{verbatim}
+%   \toolboxGobbleNext{\foo}{{arg}\end{verbatim}
+% is the same as "\foo{arg}" (the brace "{" is eaten in this example).\par
+
+% As described earlier, the commands "\futurelet" or "\toolboxFuturelet" can
+% be used to check for optional flags. Frequently you will only want
+% to test for one particular flag and decide the next action on this flag.
+% Of course, you can test the token found with "\ifx...\fi" but this has the
+% disadvantage that some tokens (e.g.\ "\fi") follow your action, which might
+% be bad (recall that e.g.\ "\toolboxGobbleNext" must be the last command of
+% your action, i.e.\ it would in the above examples not gobble the "*" but
+% the "\fi" which is probably not what you want).
+% The simplest solution is to use the command
+% \DescribeMacro{\toolboxIfNextToken}"\toolboxIfNextToken" which already
+% has the test included. For example, to test for an optional "[", you can
+% simply write
+% \begin{verbatim}
+% \def\MacroWithOptionalBrace{\toolboxIfNextToken[{\yes}{\no}}\end{verbatim}
+% and then the call "\MacroWithOptionalBrace[...]" will expand to "\yes[...]"
+% while "\MacroWithOptionalBrace x" will expand to "\no x" (note that the
+% brace is not gobbled---if you want the latter, use "\toolboxIfNextGobbling"
+% described below).\par
+% More precisely, the calling syntax of "\toolboxIfNextToken" is
+% \begin{quote}
+% \DescribeMacro{\toolboxIfNextToken}
+% "\toolboxIfNextToken"\bracemeta{token}\bracemeta{if}\bracemeta{else}
+% \end{quote}
+% The semantic is the following: If the token following this command is
+% \meta{token}, then \meta{if} is executed, otherwise \meta{else}.
+% It is explicitly admissible that \meta{token} is a space.
+% To support further tests, \DescribeMacro{\toolboxToken}"\toolboxToken"
+% is "\let" to the token which follows the command.
+% "\toolboxToken" is only a temporary token,
+% i.e.\ it may also be modified by other commands of this package;
+% in particular, you may also freely modify "\toolboxToken".\par
+% The token "\toolboxSpaceToken" which is described later may be handy
+% in connection with this command.\par
+% In contrast to similar \LaTeXe\ macros
+% much care has been taken that spaces are not eaten. This solves the
+% following problem:\par
+%
+% Assume that you want to write a macro which should have the calling syntax
+% "\mymacro{arg1}" or "\mymacro{arg1}[arg2]". You will probably implement
+% "\mymacro" to read the first argument and then to look whether the next
+% token is a "[". If you use the \LaTeXe\ macro to test for "[",
+% then all spaces until the next non-space token would be gobbled which means
+% that if you would use the \LaTeXe\ macros for the test, then the call
+% "\mymacro{arg1}"\myspace"Text" would behave like "\mymacro{arg1}Text",
+% i.e.\ the space is ``mysteriously'' lost. With the \filecite{toolbox}
+% macros this does not happen. The ``disadvantage'' is that
+% "\mymacro{arg1}"\myspace"[arg2]" is not the same as
+% "\mymacro{arg1}[arg2]" either (which is reasonable IMHO).
+%
+% Example:
+% \begin{verbatim}
+% \def\mycmd#1{\toolboxIfNextToken[{\ParseOpt{#1}}{\NoOpt{#1}}}
+%    \def\ParseOpt#1[#2]{\OptAtEnd{#1}{#2}}\end{verbatim}
+% After the above definition, "\mycmd{arg}" executes "\NoOpt{arg}" while
+% "\mycmd{arg}[optional]" executes "\OptAtEnd{arg}{optional}".
+% We point out once more that in the first call a space following
+% "\mycmd{arg}" does not vanish (as would be the case if the \LaTeXe\ macros
+% would have been used).\par
+
+% If "\toolboxIfNextToken" has found the required token, it does \emph{not}
+% gobble that token from the token stream. Of course, you can do this by
+% yourself using the earlier described macro "\toolboxGobbleNext". However,
+% it is simpler to use
+% \begin{quote}
+% \DescribeMacro{\toolboxIfNextGobbling}
+% "\toolboxIfNextGobbling"\bracemeta{token}\bracemeta{if}\bracemeta{else}
+% \end{quote}
+% This command is analogous to "\toolboxIfNextToken" with the difference that
+% in the case that the next token is \meta{token}, it is gobbled before
+% \meta{if} is executed.\par
+%
+% Example:
+% \begin{verbatim}
+% \def\my{\toolboxIfNextGobbling*\toolboxTokenLoop\toolboxLoop}\end{verbatim}
+% This makes "\my*..." behave like "\toolboxTokenLoop..." and
+% "\my..." (without "*") behave like "\toolboxLoop...".\par
+
+% The following macro is one which you may want to use in connection with
+% \LaTeX2e\ optional arguments:
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxIfEmpty}
+% "\toolboxIfEmpty"\bracemeta{arg}\bracemeta{if}\bracemeta{else}
+% \end{quote}
+%
+% \meta{arg} is not expand; it is only used to decide whether \meta{if} or
+% \meta{else} will be expanded.\par
+% For further tests there are more involved macros:
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxIfx}
+% "\toolboxIfx"\bracemeta{arg}"\macro"\bracemeta{if}\bracemeta{else}
+% \end{quote}
+% This tests via "\ifx" whether "\def\Macro"\bracemeta{arg} would give
+% the definition of "\macro".
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxIfX}
+% "\toolboxIfX"\bracemeta{arg 1}\bracemeta{arg 2}\bracemeta{if}\bracemeta{else}
+% \end{quote}
+% This tests whether \meta{arg 1} and \meta{arg 2} are the same token
+% sequences.\par
+%
+% If you want to avoid the "\else" and "\fi" commands to avoid certain side
+% effects, you can use instead:
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxIfElse}
+% "\toolboxIfElse"\bracemeta{ifcmd}\bracemeta{if}\bracemeta{else}
+% \end{quote}
+% This is rather analogous to \meta{ifcmd}\meta{if}"\else"\meta{else}"\fi"
+% but has everything in this line already eliminated from the tokenlist when
+% \meta{if} resp.\ \meta{else} are expanded.
+
+% \subsection{Loops over tokenlists and itemlists}
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxLoop}
+% "\toolboxLoop"\bracemeta{items}\bracemeta{action}
+% \end{quote}
+%
+% This calls iteratively \meta{action}"{#1}", where "#1" runs over each item in
+% \meta{items}. Here, an item is either a token or a group
+% braced by "{...}".
+% In the latter case, the braces are lost. Spaces in \meta{items} are ignored
+% (unless they are braced). It is admissible that \meta{action} is not a single
+% macro but instead a sequence of tokens.\par
+% Examples follow below.\par
+% The counterintuitive order of arguments is explained by the fact that the
+% typical usage is
+% \begin{quote}
+% "\expandafter\toolboxLoop\expandafter{\ExpandingMacro}"\bracemeta{action}
+% \end{quote}
+% which for swapped order of arguments could hardly be written.\par
+%
+% "\toolboxLoop" is not reentrant, i.e.\ \bracemeta{action} may not expand
+% to something which contains a call to "\toolboxLoop". To enable such calls
+% anyway, the command
+% \begin{quote}
+% \DescribeMacro{\toolboxLoopName}
+% "\toolboxLoopName"\bracemeta{name}\bracemeta{items}\bracemeta{action}
+% \end{quote}
+% is provided which is analogous to "\toolboxLoopName". This is also
+% not reentrant, but in contrast to "\toolboxLoop",
+% calls with different \meta{name} can
+% be used independently of each other, i.e.\ in the \bracemeta{action} part
+% of a "\toolboxLoop" (or "\toolboxLoopName") can be a call to
+% "\toolboxLoopName" with a \emph{different} \meta{name} argument.
+% In particular, using a counter in \meta{name}, one could easily implement
+% even recursive calls. In this connection, it should be noted that
+% \meta{name} is expanded via "\csname ... \endcsname", and so you may use
+% constructs like "\the\namecounter" there.\par
+
+% \begin{quote}
+% \DescribeMacro{\toolboxTokenLoop}
+% "\toolboxTokenLoop"\bracemeta{tokens}\bracemeta{action}
+% \end{quote}
+% This is similar to "\toolboxLoop": The command \meta{action}"\toolboxToken"
+% is executed iteratively where "\toolboxToken" runs over each token in
+% \meta{tokens}. The important difference is that "\toolboxToken" is a token
+% (instead of an item). In particular, "\toolboxToken" runs through every
+% single token including spaces and braces.\par
+% The token "\toolboxSpaceToken" which is described later may be handy
+% in connection with this command.\par
+
+% Example:
+% \begin{verbatim}
+% \toolboxTokenLoop{Some text}{\kern0.1em}\end{verbatim}
+% is the similar to "\kern0.1em S\kern0.1em o\kern0.1em m...", i.e.\ you
+% get wider spacing between the letters of "Some text" (I do not claim that
+% this is typographically a good idea).\par
+%
+% Note that you do not have to take special care about the space.
+% With "\toolboxLoop", you would have to mask the space e.g.\ with
+%
+% \begin{verbatim}
+% \toolboxLoop{Some{ }text}{\kern0.1em}\end{verbatim}
+% or
+% \begin{verbatim}
+% \toolboxLoop{Some\toolboxSpace text}{\kern0.1em}\end{verbatim}
+% In contrast, "\toolboxTokenLoop" would behave differently here:
+% \begin{verbatim}
+% \toolboxTokenLoop{Some{ }text}{\kern0.1em}\end{verbatim}
+% would produce "\kern0.1em S...\kern0.1em{\kern0.1em"\myspace"\kern0.1em}..."
+% because the braces are simply considered as tokens.
+
+%
+% "\toolboxTokenLoop" is not reentrant. Analogously to "\toolboxLoopName",
+% independent versions can be generated by
+% \begin{quote}
+% \DescribeMacro{\toolboxTokenName}
+% "\toolboxTokenName"\bracemeta{name}\bracemeta{tokens}\bracemeta{action}
+% \end{quote}
+
+% \subsection{Controlled expansion}
+%
+% There are some occasions when you want more control over the expansion.
+% E.g.\ you might want to concatenate the contents of two macros to a
+% further macro or you want to expand a macro by one level but no full
+% expansion. Usually you can get this effects with "\expandafter", but if
+% you expand several concatenated tokens in this way you either have to
+% write a lot of "\expandafter"s or you have to define subsidiary macros
+% that help you to "\expandafter" certain parts of macros. The macros in
+% this section allow you to do this in the most generic way that I could
+% implement.
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxDef}
+% "\toolboxDef\macrotodefine"\bracemeta{argumentlist}
+% \end{quote}
+%
+% This call is similar to
+% \begin{quote}
+% "\def\macrotodefine"\bracemeta{argumentlist}
+% \end{quote}
+% with two important differences:
+%
+% For "\toolboxDef", \meta{argumentlist} is expanded precisely by one level.
+% \meta{argumentlist} may not contain macros with parameters, and spaces in the
+% highest level are ignored. If you want to force a space on a particular
+% place, use the macro \DescribeMacro{\toolboxSpace}"\toolboxSpace" at this
+% place (which is described later). Contrary to the usual "\def", the
+% symbol "#" is treated as a usual symbol.
+%
+% Example of usage:
+% \begin{verbatim}
+%    \toolboxDef\chain{\chain\toolboxSpace\after}\end{verbatim}
+% This modifies the macro "\chain" such that a space and the content of the
+% macro "\after" is appended at the end.
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxAppend}
+% "\toolboxAppend\macrotodefine"\bracemeta{argumentlist}
+% \end{quote}
+% This is equivalent to
+% \begin{quote}
+% "\toolboxDef\macrotodefine{\macrotodefine"\meta{argumentlist}"}"
+% \end{quote}
+% \par
+
+% The macro
+% \begin{quote}
+% \DescribeMacro{\toolboxSurround}
+% "\toolboxSurround"\bracemeta{content before}\bracemeta{content after}"\macro"
+% \end{quote}
+% redefines "\macro" such that \meta{content before} is put at the
+% beginning and \meta{content after} after the definition of "\macro".
+% So this is equivalent to
+% \begin{quote}
+% "\def\macro{"\meta{content before}\meta{old content of \cmdcite{macro}}\relax
+%\meta{content after}"}"
+% \end{quote}
+% It is required that "\macro" is a usual macro without any arguments.
+% If you want to patch more complicated macros, use the \filecite{patch.doc}
+% package instead.
+
+% The order of the arguments may appear strange, but it is convenient if
+% \meta{content before} or \meta{content after} are macros which should be
+% expanded with "\expandafter".
+
+% There is some subsidiary macro used in the implementation of the above
+% macros which might be useful also in some other situations:
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxTokDef}
+% "\toolboxTokDef"\bracemeta{argumentlist}"\macrotodefine"
+% \end{quote}
+% This call is similar to
+% \begin{quote}
+% "\def\macrotodefine"\bracemeta{argumentlist}
+% \end{quote}
+% with the difference that the symbol "#" is stored as such.
+% The order of the arguments has been swapped in order to simplify the
+% application of "\expandafter" to \meta{argumentlist}.
+%
+
+% \subsection{Searching, splitting, and replacing}
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxSplitAt}
+% "\toolboxSplitAt"\bracemeta{argument}\bracemeta{search}\relax
+%"{\beforestring}{\afterstring}"
+% \end{quote}
+%
+% Here, "\beforestring" and "\afterstring" are arbitrary macro names,
+% and \meta{search} and \meta{argument} are any sequences of tokens (which
+% are in the following considered as `strings').
+%
+% This call scans \meta{argument} for the first occurrence of \meta{search}.
+% The macros "\beforestring" and "\afterstring"  are defined correspondingly
+% such that "\beforestring" expands to the part before the first occurrence,
+% and "\afterstring" to the part following the first occurrence.
+% If \meta{search} does not occur in \meta{argument}, "\beforestring" is
+% defined to \meta{argument}, and "\afterstring" is "\let" "\undefined".
+%
+% If "\beforestring" or "\afterstring" had already been defined before the
+% call, the previous definition is tacitly overridden.
+% It is explicitly allowed that "\beforestring" and "\afterstring" are the
+% same names. In this case, the result has the meaning of "\afterstring".
+%
+% It is guaranteed that braces "{...}" are \emph{not} lost in \meta{argument}.
+% However, \meta{search} may not contain any braces, and \meta{argument} may
+% contain only matching pairs of braces. Moreover, occurrences of \meta{search}
+% within a pair of braces in \meta{argument} are not recognized.
+%
+% (The order of the arguments has been chosen in order to simplify the
+% use of "\expandafter").
+%
+% There are some restrictions for the strings in search. For example,
+% the symbol "#" is not allowed.
+%
+% In the above call, the arguments may not run over several paragraphs.
+% If you want the latter, you have to use the alternative call
+% \begin{quote}
+% "\toolboxSplitAt*"\bracemeta{argument}\bracemeta{search}\relax
+%"{\beforestring}{\afterstring}"
+% \end{quote}
+
+%
+% Example of usage:
+%
+% \begin{verbatim}
+% \def\examplemacro#1{\toolboxSplitAt{#1}{@}\testme\testme
+%   \ifx\testme\undefined
+%      ... (do this when #1 contains no `@' token)
+%   \fi}\end{verbatim}
+%
+
+% If "\toolboxSplitAt" should be used several times with the same
+% \meta{search} string, it is much more efficient to use the following command:
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxMakeSplit}
+% "\toolboxMakeSplit"\bracemeta{search}"{command}"
+% \end{quote}
+%
+% This call defines a new macro "\command" (the name is determined by the
+% second argument of "\toolboxMakeSplit") which can be called in the form
+%
+% \begin{quote}
+% "\command"\bracemeta{argument}"{\beforestring}{\afterstring}"
+% \end{quote}
+%
+% and which has the analogous meaning as "\SplitAt" (the argument
+% \bracemeta{search} is implicitly fixed and taken from the call of
+% "\toolboxMakeSplit").
+% It is explicitly admissible that the above macro "\toolboxMakeSplit" is
+% used with an already existing command name. In this case, the previous
+% definition of "\command" is tacitly overridden.
+%
+% The command created by "\toolboxMakeSplit" does not accept arguments which
+% run over several paragraphs. If you want the latter, you have to create
+% this command by the alternative call
+%
+% \begin{quote}
+% "\toolboxMakeSplit*"\bracemeta{search}"{command}"
+% \end{quote}
+
+% The command
+% \begin{quote}
+%    "\toolboxFreeSplit"\bracemeta{command}
+% \end{quote}
+% frees the memory used by a previous "\toolboxMakeSplit" (and lets "\command"
+% again be undefined).
+
+% The command
+% \begin{quote}
+%   \DescribeMacro{\toolboxReplace}
+%   "\toolboxReplace"\bracemeta{search}\bracemeta{replace}"\macro"
+% \end{quote}
+% replaces in "\macro" all occurences of \meta{search} by \meta{replace}.
+% The same matches are found as in "\toolboxSplitAt".
+% If you need to search for the same text several times, it is faster
+% to use the command
+% \begin{quote}
+%   \DescribeMacro{\toolboxReplaceSplit}
+%   "\toolboxReplaceSplit"\bracemeta{replace}"\SplitCmd\macro"
+% \end{quote}
+% where "\SplitCmd" is a command previously generated with "\toolboxMakeSplit*"
+% according to your \meta{search} string. (You could also use
+% "\toolboxMakeSplit" to generate "\SplitCmd", but then "\macro" should not
+% contain any "\par"s).
+
+% \subsection{Redefinition of macros}
+%
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxMakeHarmless}
+% "\toolboxMakeHarmless{\macro}"
+% \end{quote}
+%
+% The above call redefines "\macro" such that it expands to an ASCII text
+% containing the previous definition of "\macro" (i.e.\ the catcodes of
+% "\macro" are changed).
+
+% The call
+% \begin{quote}
+% \DescribeMacro{\toolboxDropBrace}
+% "\toolboxDropBrace{\macro}"
+% \end{quote}
+% drops possible outer braces of "\macro". More precisely,
+% if "\macro" expands to \bracemeta{content}, then "\macro" is redefined
+% to \meta{content} (without braces). Otherwise, nothing happens.
+
+% The command
+% \begin{quote}
+% \DescribeMacro{\toolboxIf}
+% "\toolboxIf"\meta{comparison}\bracemeta{definition commands}\relax
+%\cmdmeta{macro}$\ldots$
+% \end{quote}
+% allows conditional definitions. Here, \bracemeta{definition command}
+% is either "\def", "{\long\def}", "\let", or some similar command like
+% e.g.\ the \LaTeX\ "\newcommand". If the test
+% "\ifx"\meta{comparison}\cmdmeta{macro} evaluates positive, then
+% \cmdmeta{macro} is defined correspondingly. Otherwise, \cmdmeta{macro}
+% is not changed.\par\smallskip
+%
+% \textbf{Examples:}
+%
+% \begin{verbatim}
+% \toolboxIf\undefined\def\macro{....}
+% \toolboxIf\undefined\let\macro...
+% \toolboxIf\undefined{\long\def}\macro{....}
+% \toolboxIf\undefined\newcommand{\macro}{....}\end{verbatim}
+%
+% are similar to "\def\macro{...}" resp.\ "\let\macro..."
+% resp.\ "\long\def\macro{...}" resp.\ "\newcommand{\macro}" with the
+% difference that "\macro" is not changed if it was already defined.
+% In this sense, "\toolboxIf" is a more flexible variant of "\providecommand".
+%
+
+% The commands
+% \begin{quote}
+% \DescribeMacro{\toolboxNewiftrue}
+%   "\toolboxNewiftrue"\bracemeta{name}\\
+% \DescribeMacro{\toolboxNewiffalse}
+%   "\toolboxNewiffalse"\bracemeta{name}
+% \end{quote}
+% test whether the command "\if"\meta{name} was already introduced with
+% "\newif"; in this case nothing happens. Otherwise, "\if"\meta{name} is
+% introduced similarly to "\newif\if"\meta{name} and set to "true"
+% respectively "false".
+% In contrast to the corresponding command in \TeX\ or \LaTeX 2.09, this macro
+% is not "\outer"!
+% \begin{quote}
+% \DescribeMacro{\toolboxNewifTrue}
+%   "\toolboxNewifTrue"\bracemeta{name}\\
+% \DescribeMacro{\toolboxNewifFalse}
+%   "\toolboxNewifFalse"\bracemeta{name}
+% \end{quote}
+% are similar to "\toolboxNewiftrue"\bracemeta{name} and
+% "\toolboxNewiffalse"\bracemeta{name}, respectively,
+% with the difference that "\if"\meta{name} is set unconditionally
+% to "true" respectively "false".
+
+% \subsection{Concatenated macro names}
+%
+% \begin{quote}
+% \DescribeMacro{\toolboxLet}
+% "\toolboxLet\variable"\bracemeta{macroname}
+% \end{quote}
+% The above command is analogous to "\let\variable\macroname" with the
+% difference that \meta{macroname} can also contain other tokens like numbers
+% (it is obtained via "\csname"). Some converse to this command is
+%
+% \begin{quote}
+% "\toolboxWithNr"\bracemeta{number}"\command"\bracemeta{macro}
+% \end{quote}
+% which translates into "\command\macronumber" (here, \meta{macro} and
+% \meta{number} are just concatenated and evaluated via "\csname").
+% Examples:
+% \begin{verbatim}
+%   \toolboxWithNr 1\let{name}\toolboxEmpty\end{verbatim}
+% This is the same as "\let\name1\toolboxEmpty" (but such that "\name1" is
+% considered as a name, not as "\name 1")
+% \begin{verbatim}
+% \toolboxWithNr {10}\def{name}{Foo}\end{verbatim}
+% This corresponds analogously to "\def\name10{Foo}".
+% \begin{verbatim}
+% \toolboxLet\mymacro{name\the\mycount}\end{verbatim}
+% This is similar to "\let\mymacro\namexx" where "xx" is the content
+% of the counter "\mycount".
+
+% \subsection{Various}
+%
+% The following macros have equivalents in most formats (like \LaTeXe).
+% However, we do not want to rely too much on these formats, so we provide
+% our own definitions.
+% The macro
+% \begin{quote}
+%    \DescribeMacro{\toolboxEmpty}"\toolboxEmpty"
+% \end{quote}
+% expands to nothing (usually, this is the same as "\empty").
+% Similarly, the macro
+% \begin{quote}
+%    \DescribeMacro{\toolboxSpace}"\toolboxSpace"
+% \end{quote}
+% expands to a space symbol (usually, this is the same as "\space").
+% The token
+% \begin{quote}
+%    \DescribeMacro{\toolboxSpaceToken}"\toolboxSpaceToken"
+% \end{quote}
+% is "\let" a space token (usually, this is the same as "\@sptoken").
+% This token is convenient in tests of tokens
+% (because it is hard to get a space there which is not eaten by the
+% \TeX\ parser, although sometimes also constructions like
+% \begin{verbatim}
+%   \expandafter\ifx\toolboxSpace\token\end{verbatim}
+% can be used). Also the macros
+% \begin{quote}
+%    \DescribeMacro{\toolboxFirstOfTwo}"\toolboxFirstOfTwo"\\
+%    \DescribeMacro{\toolboxSecondOfTwo}"\toolboxSecondOfTwo"
+% \end{quote}
+% are provided which read two arguments and return only the first
+% respectively second argument (usually, this is the same as
+% "\@firstoftwo" respectively "\@secondoftwo"). Similarly,
+% \begin{quote}
+% \DescribeMacro{\toolboxGobbleArg}
+% "\toolboxGobbleArg"\bracemeta{argument}
+% \end{quote}
+% just reads its argument and expands to nothing.
+
+% \iffalse
+%</metainfo>
+% \fi
+% \iffalse--------------------------------------------------------------\fi
+% \StopEventually{\PrintChanges}
+%                     \section{Implementation}
+%
+% \iffalse--------------------------------------------------------------
+%
+%
+%<*package>
+% \fi
+%    \begin{macrocode}
+%%
+%% This file was generated by the docstrip utility from toolbox.dtx.
+%% You may distribute this file only together with the source toolbox.dtx
+%% (and if possible with toolbox.ins) and only if these files are unmodified.
+%%
+%% Author:
+%%
+%% M. V\"ath      vaeth@mathematik.uni-wuerzburg.de
+%%
+
+\ifx\typeout\undefined
+  \def\tbx@tmp{\immediate\write17}\expandafter\tbx@tmp
+\else
+  \expandafter\typeout
+\fi{toolbox.sty by M. Vaeth: The TeX Programmer's Toolbox 5.1}
+
+%% First, some LaTeX support:
+%% We inform LaTeX that this is a package, and we test whether we would
+%% override some existing commands.
+
+\ifx\ProvidesPackage\undefined\else
+  \ProvidesPackage{toolbox}[2004/04/29 v5.1]
+\fi
+
+\ifx\newcommand\undefined\else
+  \newcommand{\toolboxMakeDef}{}
+  \newcommand{\toolboxFreeDef}{}
+  \newcommand{\toolboxFuturelet}{}
+  \newcommand{\toolboxGobbleNext}{}
+  \newcommand{\toolboxIfNextToken}{}
+  \newcommand{\toolboxIfNextGobbling}{}
+  \newcommand{\toolboxIfEmpty}{}
+  \newcommand{\toolboxIfx}{}
+  \newcommand{\toolboxIfX}{}
+  \newcommand{\toolboxIfElse}{}
+  \newcommand{\toolboxLoop}{}
+  \newcommand{\toolboxLoopName}{}
+  \newcommand{\toolboxToken}{}
+  \newcommand{\toolboxTokenName}{}
+  \newcommand{\toolboxTokDef}{}
+  \newcommand{\toolboxDef}{}
+  \newcommand{\toolboxAppend}{}
+  \newcommand{\toolboxSplitAt}{}
+  \newcommand{\toolboxMakeSplit}{}
+  \newcommand{\toolboxFreeSplit}{}
+  \newcommand{\toolboxReplace}{}
+  \newcommand{\toolboxReplaceSplit}{}
+  \newcommand{\toolboxMakeHarmless}{}
+  \newcommand{\toolboxDropBrace}{}
+  \newcommand{\toolboxIf}{}
+  \newcommand{\toolboxNewiftrue}{}
+  \newcommand{\toolboxNewiffalse}{}
+  \newcommand{\toolboxLet}{}
+  \newcommand{\toolboxWithNr}{}
+  \newcommand{\toolboxEmpty}{}
+  \newcommand{\toolboxSpace}{}
+  \newcommand{\toolboxSpaceToken}{}
+  \newcommand{\toolboxFirstOfTwo}{}
+  \newcommand{\toolboxSecondOfTwo}{}
+  \newcommand{\toolboxGobbleArg}{}
+\fi
+
+%    \end{macrocode}
+% \subsection{Macros for various purposes}
+% \begin{macro}{\toolboxSpace}\nocomment
+%    \begin{macrocode}
+\def\toolboxEmpty{}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxSpace}\nocomment
+%    \begin{macrocode}
+\def\toolboxSpace{ }
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxSpaceToken}
+%  We cannot just write
+%  \begin{verbatim*}\let\toolboxSpaceToken= \end{verbatim*}
+%  because then the space would be eaten by \TeX's parser.
+%  Also tries like
+%  \begin{verbatim}
+%  \expandafter\let\expandafter\toolboxSpaceToken\toolboxSpace\end{verbatim}
+%  do not work for similar reasons. In contrast,
+%  \begin{verbatim}
+%  \futurelet\toolboxSpaceToken{ }\end{verbatim}
+%  is possible (because the space is not `really' parsed at this time),
+%  but it would have the side effect that the group "{ }" is executed which
+%  forces a space output. We could artificially `eat' this output in some box.
+%  But we proceed differently by replacing "{ }" in
+%  the above call by an appropriate "\if...\fi". Of course, we have to take
+%  care that the space is not eaten too early.
+%    \begin{macrocode}
+\expandafter
+  \futurelet\expandafter\toolboxSpaceToken\expandafter
+    \if\toolboxSpace\toolboxEmpty\toolboxEmpty\fi
+
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxFirstOfTwo}\nocomment
+%    \begin{macrocode}
+\long\def\toolboxFirstOfTwo#1#2{#1}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxSecondOfTwo}\nocomment
+%    \begin{macrocode}
+\long\def\toolboxSecondOfTwo#1#2{#2}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxGobbleArg}
+%    \begin{macrocode}
+\long\def\toolboxGobbleArg#1{}
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\tbx@toks}
+% We need a temporary token list
+%    \begin{macrocode}
+\toksdef\tbx@toks=0
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \subsection{Macros supporting implicit macro definitions}
+%
+% \begin{macro}{\toolboxMakeDef}\nocomment
+%    \begin{macrocode}
+\def\toolboxMakeDef{\tbx@MakeNames\tbx@MakeDef}
+%    \end{macrocode}
+%  \begin{macro}{\tbx@MakeDef}
+% The macros for "\toolboxMakeDef" are defined with
+% \begin{quote}
+%  "\tbx@MakeDef\PrefixNewName\PrefixRenewName\PrefixProvideName%"\\
+%  "  \PrefixDefName\PrefixLetName\PrefixName\tbx@e@Prefix@Name%"\\
+%  "  "\bracemeta{Prefix}\bracemeta{Name}\bracemeta{Replacement Mask}
+% \end{quote}
+% Note that \meta{Replacement Mask} must be read implicitly, because it
+% contains "#1" which is usually forbidden.
+% The macro "\tbx@e@Prefix@Name" is defined as
+% \begin{quote}
+%   "\tbx@long\def\tbx@e@Name#1"\bracemeta{Replacement Mask}
+% \end{quote}
+% The macros generated by
+% \begin{quote}
+% "\PrefixNewName"\bracemeta{something}"{"$\ldots$"...}"
+% \end{quote}
+% carry the names
+% \begin{quote}
+% "\tbx@l@"\meta{Prefix}"@"\meta{Name}"@"\meta{something}
+% \end{quote}
+% Observe that the symbol "@" has currently the exceptional letter catcode,
+% so that there is no danger that the user mangles up the names (unless he
+% uses "\makeatletter" which he should of course not do, usually).
+% \makeatletter
+%    \begin{macrocode}
+\def\tbx@MakeDef#1#2#3#4#5#6#7#8#9{%
+  \tbx@def#1{\toolboxIfNextGobbling*%
+    {\tbx@MakeNew\let{#8}{#9}}{\tbx@MakeNew\def{#8}{#9}}}%
+  \tbx@def#2{\toolboxIfNextGobbling*%
+    {\tbx@MakeRenew\let{#8}{#9}}{\tbx@MakeRenew\def{#8}{#9}}}%
+  \tbx@def#3{\toolboxIfNextGobbling*%
+    {\tbx@MakeProvide\let{#8}{#9}}{\tbx@MakeProvide\def{#8}{#9}}}%
+  \tbx@def#4{\toolboxIfNextGobbling*%
+    {\tbx@MakeForce\let{#8}{#9}}{\tbx@MakeForce\def{#8}{#9}}}%
+  \tbx@def#5##1##2{\expandafter
+    \tbx@MakeLet\csname tbx@l@#8@#9@##2\endcsname##1}%
+  \tbx@def#6{\toolboxIfNextGobbling*%
+    {\tbx@MakeUse\tbx@itemEnd{#8}{#9}}{\tbx@MakeUse\relax{#8}{#9}}}%
+  \long\def#7##1}
+
+%    \end{macrocode}
+%   \begin{macro}{\tbx@MakeNew}
+% "\tbx@MakeNew"\bracemeta{mode}\relax
+%\bracemeta{Prefix}\bracemeta{Name}\bracemeta{something}%
+%\bracemeta{text to remember}
+%    \begin{macrocode}
+\def\tbx@MakeNew#1#2#3#4{\expandafter
+  \ifx\csname tbx@l@#2@#3@#4\endcsname\relax\else
+    \errmessage{#2New#3: entry #4 already exists}%
+  \fi
+  \tbx@MakeForce{#1}{#2}{#3}{#4}}
+
+%    \end{macrocode}
+%   \end{macro}
+%   \begin{macro}{\tbx@MakeRenew}
+% "\tbx@MakeRenew"\bracemeta{mode}\relax
+%\bracemeta{Prefix}\bracemeta{Name}\bracemeta{something}%
+%\bracemeta{text to remember}
+%    \begin{macrocode}
+\def\tbx@MakeRenew#1#2#3#4{\expandafter
+  \ifx\csname tbx@l@#2@#3@#4\endcsname\relax
+    \errmessage{#2Renew#3: entry #4 was not defined before}%
+  \fi
+  \tbx@MakeForce{#1}{#2}{#3}{#4}}
+
+%    \end{macrocode}
+%   \end{macro}
+%   \begin{macro}{\tbx@MakeProvide}
+% "\tbx@MakeProvide"\bracemeta{mode}\relax
+%\bracemeta{Prefix}\bracemeta{Name}\bracemeta{something}%
+%\bracemeta{text to remember}
+%    \begin{macrocode}
+\def\tbx@MakeProvide#1#2#3#4#5{\expandafter
+  \ifx\csname tbx@l@#2@#3@#4\endcsname\relax
+    \tbx@MakeForce{#1}{#2}{#3}{#4}{#5}%
+  \fi}
+
+%    \end{macrocode}
+%   \end{macro}
+%   \begin{macro}{\tbx@MakeForce}
+% "\tbx@MakeForce"\bracemeta{mode}\relax
+%\bracemeta{Prefix}\bracemeta{Name}\bracemeta{something}%
+%\bracemeta{text to remember}
+%    \begin{macrocode}
+\long\def\tbx@MakeForce#1#2#3#4#5{%
+  \ifx#1\let
+    \expandafter
+      \let\csname tbx@l@#2@#3@#4\endcsname#5%
+  \else
+    \expandafter
+      \tbx@MakeDoDef\csname tbx@l@#2@#3@#4\expandafter\endcsname
+        \csname tbx@e@#2@#3\endcsname{#5}%
+  \fi}
+%    \end{macrocode}
+%    \begin{macro}{\tbx@MakeDoDef}
+% \begin{quote}
+% "\tbx@MakeDoDef"\relax
+%"\tbx@l@"\meta{Prefix}"@"\meta{Name}"@"\meta{something}"%"\\
+%"  \tbx@e@"\meta{Prefix}"@"\meta{Name}\bracemeta{text to remember}
+% \end{quote}
+%    \begin{macrocode}
+\long\def\tbx@MakeDoDef#1#2#3{\tbx@toks\expandafter{#2{#3}}%
+  \edef#1{\the\tbx@toks}}
+
+%    \end{macrocode}
+%    \end{macro}
+%   \end{macro}
+%   \begin{macro}{\tbx@MakeLet}
+% "\tbx@MakeLet"\cmdmeta{Prefix}"@"\meta{Name}"@"\meta{something}\relax
+%\cmdmeta{something}
+%    \begin{macrocode}
+\def\tbx@MakeLet#1#2{%
+  \ifx#1\relax
+    \let#2\undefined
+  \else
+    \let#2#1%
+  \fi}
+
+%    \end{macrocode}
+%   \end{macro}
+%   \begin{macro}{\tbx@MakeUse}
+% "\tbx@MakeUse"\bracemeta{mode}\relax
+%\bracemeta{Prefix}\bracemeta{Name}\bracemeta{something}
+%    \begin{macrocode}
+\def\tbx@MakeUse#1#2#3#4{%
+  \expandafter
+  \ifx\csname tbx@l@#2@#3@#4\endcsname#1%
+    \errmessage{Entry #4 was not defined with
+    #2New#3, #2Provide#3, or #2Def#3}%
+  \fi
+  \csname tbx@l@#2@#3@#4\endcsname}
+
+%    \end{macrocode}
+%   \end{macro}
+%   \begin{macro}{\tbx@def}
+% "\tbx@def" is similar to "\def", but existence is tested (via "\relax")
+%    \begin{macrocode}
+\def\tbx@def#1{%
+  \ifx#1\relax\else
+    \errmessage{\string#1 is already defined}%
+  \fi
+  \def#1}
+
+%    \end{macrocode}
+%   \end{macro}
+%  \end{macro}
+%  \begin{macro}{\toolboxFreeDef}\nocomment
+%    \begin{macrocode}
+\def\toolboxFreeDef{\toolboxIfNextGobbling*%
+  {\tbx@MakeNames{\tbx@FreeDef\relax}}{\tbx@MakeNames{\tbx@FreeDef\undefined}}}
+%    \end{macrocode}
+%   \begin{macro}{\tbx@FreeDef}
+%  \begin{quote}
+%  "\tbx@FreeDef"\bracemeta{mode}"\PrefixNewName\PrefixRenewName%"\\
+%  "  \PrefixProvideName\PrefixDefName\PrefixLetName\PrefixName"%\\
+%  "  \tbx@e@Prefix@Name"\bracemeta{Prefix}\bracemeta{Name}
+%  \end{quote}
+%  The last two arguments are not needed, but we must gobble them.
+%  Since a macro can have at most 9 arguments, we must gobble the last one
+%  separately.
+%    \begin{macrocode}
+\def\tbx@FreeDef#1#2#3#4#5#6#7#8#9{%
+  \let#2\undefined\let#3\undefined\let#4\undefined\let#5\undefined
+  \let#8\undefined
+  \ifx#1\undefined
+    \let#6\undefined\let#7\undefined
+  \fi\toolboxGobbleArg}
+
+%    \end{macrocode}
+%   \end{macro}
+%  \end{macro}
+%  \begin{macro}{\tbx@MakeNames}
+% The call
+% \begin{quote}
+%  "\tbx@MakeNames"\bracemeta{commands}"["\meta{Prefix}"]"\bracemeta{Name}
+% \end{quote}
+% (where the "["\meta{Prefix}"]" argument is optional) expands to
+% \begin{quote}
+%   \meta{commands}"\PrefixNewName\PrefixRenewName\PrefixProvideName%"\\
+%   "  \PrefixLetName\PrefixName\tbx@e@Prefix@Name%"\\
+%   "  "\bracemeta{Prefix}\bracemeta{Name}
+% \end{quote}
+%    \begin{macrocode}
+\def\tbx@MakeNames#1{\toolboxIfNextToken[%]
+  {\tbx@MakingNames{#1}}{\tbx@MakingNames{#1}[]}}
+%    \end{macrocode}
+%   \begin{macro}{\tbx@MakingNames}
+%    \begin{macrocode}
+\def\tbx@MakingNames#1[#2]#3{\expandafter
+  \tbx@ListSwap\expandafter{%
+    \csname#2New#3\expandafter\endcsname
+    \csname#2Renew#3\expandafter\endcsname
+    \csname#2Provide#3\expandafter\endcsname
+    \csname#2Def#3\expandafter\endcsname
+    \csname#2Let#3\expandafter\endcsname
+    \csname#2#3\expandafter\endcsname
+    \csname tbx@e@#2@#3\endcsname{#2}{#3}}{#1}}
+%    \end{macrocode}
+%    \begin{macro}{\tbx@ListSwap}\nocomment
+%    \begin{macrocode}
+\def\tbx@ListSwap#1#2{#2#1}
+
+%    \end{macrocode}
+%    \end{macro}
+%   \end{macro}
+%  \end{macro}
+% \end{macro}
+%
+% \subsection{Macros supporting fancy optional argument parsing}
+%
+% \begin{macro}{\toolboxFuturelet}
+%    \begin{macrocode}
+\long\def\toolboxFuturelet#1#2{\toolboxTokDef{#2}\tbx@tmp\futurelet#1\tbx@tmp}
+
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxGobbleNext}
+%    \begin{macrocode}
+\long\def\toolboxGobbleNext#1{\toolboxTokDef{#1}\tbx@tmp
+  \afterassignment\tbx@tmp
+  \let\toolboxToken= }% The space here is important to read spaces properly
+
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxIfNextToken}
+%    \begin{macrocode}
+\long\def\toolboxIfNextToken#1#2#3{%
+  \toolboxFuturelet\toolboxToken{%
+    \ifx#1\toolboxToken
+      \expandafter\toolboxFirstOfTwo
+    \else
+      \expandafter\toolboxSecondOfTwo
+    \fi{#2}{#3}}}
+
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxIfNextGobbling}
+%    \begin{macrocode}
+\long\def\toolboxIfNextGobbling#1#2#3{%
+  \toolboxIfNextToken{#1}{\toolboxGobbleNext{#2}}{#3}}
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \subsection{Macros supporting loops over tokenlists and itemlists}
+%
+% \begin{macro}{\toolboxLoop}
+%    "\toolboxLoop" just calls "\tbx@item" with the magic names
+%    "\tbx@i" and "\tbx@I".
+%    \begin{macrocode}
+\long\def\toolboxLoop#1#2{\tbx@item\tbx@i\tbx@I{#1}{#2}}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxLoopName}
+%    "\toolboxLoopName" calls "\tbx@item" with the magic names "\tbx@i@#1"
+%    and "\tbx@I#@1"
+%    \begin{macrocode}
+\long\def\toolboxLoopName#1#2#3{\tbx@LoopName{#1}iI\tbx@item{#2}{#3}}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\tbx@LoopName}
+% \begin{verbatim}
+%    \tbx@LoopName{name}{x}{y}{\exec}\end{verbatim}
+%  is equivalent to
+%  \begin{verbatim}
+%    \exec\tbx@x@name\tbx@y@name\end{verbatim}
+%    \begin{macrocode}
+\def\tbx@LoopName#1#2#3#4{%
+  \expandafter#4\csname tbx@#2@#1\expandafter\endcsname
+    \csname tbx@#3@#1\endcsname}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\tbx@item}
+% The call
+% \begin{quote}
+%    "\tbx@item{\MagicNameA}{\MagicNameB}"\bracemeta{items}\bracemeta{action}
+% \end{quote}
+% is the essential part of "\toolboxLoop". It has the same semantic with
+% the only difference that the names "\MagicNameA" and "\MagicNameB" are used
+% as temporary macros (they are the reason why "\tbx@item" is not reentrant).
+%    \begin{macrocode}
+\long\def\tbx@item#1#2#3#4{%
+  \long\def#1##1{%
+    \toolboxTokDef{##1}\toolboxToken
+    \ifx\toolboxToken\tbx@itemEnd
+      \def#2{\let#1\undefined\let#2\undefined}%
+    \else
+      #4{##1}%
+    \fi
+    #2}%
+  \let#2#1%
+  #1#3\tbx@itemEnd}
+%    \end{macrocode}
+%  \begin{macro}{\tbx@itemEnd}
+%  "\tbx@itemEnd" is the magic token used to mark the end of the list in
+%  "\tbx@item".
+%  Of course, we could also use any other macro instead, but this is unique,
+%  even if we compare with "\ifx". Moreover, we want a short macro to
+%  avoid unnecessary redundancy in comparing with "\ifx".
+%  It appears not necessary to make this token change in recursions, because
+%  in each expansion of a list, the newest item will automatically be the
+%  earliest.
+%    \begin{macrocode}
+\def\tbx@itemEnd{\tbx@itemEnd}
+
+%    \end{macrocode}
+%  \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\toolboxTokenLoop}
+%    "\toolboxTokenLoop" just calls "\tbx@token" with the magic names
+%    "\tbx@t" and "\tbx@T".
+%    \begin{macrocode}
+\long\def\toolboxTokenLoop#1#2{\tbx@token\tbx@t\tbx@T{#1}{#2}}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxTokenLoopName}
+%   "\toolboxTokenLoopName" calls "\tbx@token" with the magic names "\tbx@t@#1"
+%   and "\tbx@T#@1"
+%    \begin{macrocode}
+\long\def\toolboxTokenLoopName#1#2#3{\tbx@LoopName{#1}tT\tbx@token{#2}{#3}}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\tbx@token}
+%  The call
+%  \begin{quote}
+%    "\tbx@token{\MagicNameA}{\MagicNameB}"\bracemeta{items}\bracemeta{action}
+%  \end{quote}
+%  is the essential part of "\toolboxTokenLoop". It has the same semantic with
+%  the only difference that the names "\MagicNameA" and "\MagicNameB" are used
+%  as temporary macros (they are the reason why "\tbx@token" is not reentrant).
+%    \begin{macrocode}
+\long\def\tbx@token#1#2#3#4{%
+  \def#1{%
+    \ifx\toolboxToken\tbx@tokenEnd
+      \def#2{\let#1\undefined\let#2\undefined}%
+    \else
+      #4\toolboxToken
+    \fi
+    #2}%
+  \def#2{\afterassignment#1\let\toolboxToken= }%
+  #2#3\tbx@tokenEnd}
+%    \end{macrocode}
+%  \begin{macro}{\tbx@tokenEnd}
+%  "\tbx@tokenEnd" is the magic token used to mark the end of the list
+%  for "\tbx@token".
+%  The same remarks as for "\tbx@itemEnd" hold. However, it is not clear
+%  whether we could just use "\tbx@itemEnd" instead, because the scan rules
+%  for "\tbx@token" and "\tbx@item" are somewhat different, and thus it is
+%  not immediately clear whether in some fancy situations such lists (if
+%  called cross-wise) could overlap: I found no example, but I also did not
+%  put too much effort in finding one. In any case, we are on the sure side,
+%  if we just use a different token.
+%    \begin{macrocode}
+\def\tbx@tokenEnd{\tbx@tokenEnd}
+
+%    \end{macrocode}
+%  \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\toolboxIfEmpty}
+%    \begin{macrocode}
+\long\def\toolboxIfEmpty#1{\toolboxIfx{#1}\toolboxEmpty}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxIfX}
+%    \begin{macrocode}
+\long\def\toolboxIfX#1#2{\toolboxTokDef{#1}\tbx@ifx\toolboxIfx{#2}\tbx@ifx}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxIfx}
+%    \begin{macrocode}
+\long\def\toolboxIfx#1#2{\toolboxTokDef{#1}\tbx@tmp
+  \toolboxIfElse{\ifx\tbx@tmp#2}}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxIfElse}
+%    \begin{macrocode}
+\long\def\toolboxIfElse#1{#1\expandafter
+  \toolboxFirstOfTwo\else\expandafter\toolboxSecondOfTwo\fi}
+
+%    \end{macrocode}
+% \end{macro}
+%
+%
+% \subsection{Macros supporting controlled expansion}
+%
+% \begin{macro}{\toolboxTokDef}\nocomment
+%    \begin{macrocode}
+\long\def\toolboxTokDef#1#2{\tbx@toks{#1}\edef#2{\the\tbx@toks}}
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\toolboxDef}
+%  This is mainly a call of "\toolboxLoopName". It is slightly faster if we
+%  call "\tbx@item" immediately (and then we can also give magic names which do
+%  not clash with any other names). Also for time and memory reasons, we always
+%  assume that the temporary variable
+%  \begin{macro}{\tbx@odeftmp}
+%  "\tbx@odeftmp"
+%  \end{macro}
+%  is "\toolboxEmpty" at the beginning; we reset it to "\toolboxEmpty" at
+% the end (so that the memory is freed).
+%    \begin{macrocode}
+\def\toolboxDef#1#2{%
+  \tbx@item\tbx@odefa\tbx@odefb{#2}\tbx@odef
+  \let#1\tbx@odeftmp\let\tbx@odeftmp\toolboxEmpty}
+\let\tbx@odeftmp\toolboxEmpty
+%    \end{macrocode}
+%  \begin{macro}{\tbx@odef}
+%    \begin{macrocode}
+\long\def\tbx@odef#1{\expandafter\tbx@odefapp\expandafter{#1}}
+%    \end{macrocode}
+%  \end{macro}
+%  \begin{macro}{\tbx@odefapp}
+%    "\tbx@odefapp" appends its argument to "\tbx@odeftmp".
+%    \begin{macrocode}
+\long\def\tbx@odefapp#1{\tbx@toks\expandafter{\tbx@odeftmp#1}%
+  \edef\tbx@odeftmp{\the\tbx@toks}}
+
+%    \end{macrocode}
+%  \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\toolboxAppend}\nocomment
+%    \begin{macrocode}
+\def\toolboxAppend#1#2{\toolboxDef#1{#1#2}}
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\toolboxSurround}\nocomment
+%    \begin{macrocode}
+\long\def\toolboxSurround#1#2#3{\tbx@toks{#1}%
+  \tbx@toks\expandafter{\the\expandafter\tbx@toks#3#2}%
+  \edef#3{\the\tbx@toks}}
+
+%    \end{macrocode}
+% \end{macro}
+%
+%
+% \subsection{Macros supporting searching, splitting, and replacing}
+%
+% \begin{macro}{\toolboxMakeSplit}\nocomment
+%    \begin{macrocode}
+\def\toolboxMakeSplit{%
+  \toolboxIfNextGobbling*\tbx@MakeLong\tbx@MakeShort}
+%    \end{macrocode}
+%
+%  \begin{macro}{\tbx@Makelong}
+%  \begin{quote}
+%     "\tbx@Makelong"\bracemeta{search}"{cmd}"
+%  \end{quote}
+%   is the same as
+%  \begin{quote}
+%     "\tbx@DoSplitInstance{\cmd}{\tbx@cmd@spt}{\tbx@cmd@rst}"
+%\bracemeta{search}"\long"
+%  \end{quote}
+%    \begin{macrocode}
+\long\def\tbx@MakeLong#1#2{%
+  \tbx@SplitNames{#2}%
+  \expandafter
+    \tbx@DoSplitInstance\tbx@splt{#1}\long}
+%    \end{macrocode}
+%  \end{macro}
+%  \begin{macro}{\tbx@MakeShort}
+%  "\tbx@Makeshort" is essentially the same as "\tbx@Makelong" (just that
+%  "\long" is missing, of course). We could have used the same macro with
+%  an additional argument, but it is more convenient for the user if this
+%  macro itself is not "\long" so that new paragraphs in the passed search
+%  string already give an error: It makes no sense to look for new paragraphs
+%  in texts which may not contain new paragraphs.
+%    \begin{macrocode}
+\def\tbx@MakeShort#1#2{%
+  \tbx@SplitNames{#2}%
+  \expandafter
+    \tbx@DoSplitInstance\tbx@splt{#1}{}}
+%    \end{macrocode}
+%  \end{macro}
+%
+%  \begin{macro}{\tbx@SplitNames}
+%   The call "\tbx@SplitNames{cmd}" is equivalent to
+%    \begin{verbatim}
+%    \def\tbx@splt{\cmd \tbx@cmd@spt \tbx@cmd@rst}\end{verbatim}
+%    \begin{macrocode}
+\def\tbx@SplitNames#1{%
+  \expandafter
+    \def\expandafter\tbx@splt\expandafter{\csname#1\expandafter\endcsname
+      \csname tbx@#1@spt\expandafter\endcsname
+      \csname tbx@#1@rst\endcsname}}
+%    \end{macrocode}
+%  \end{macro}
+%
+%  \begin{macro}{\tbx@DoSplitInstance}
+% The call
+%   \begin{quote}
+%   "\tbx@DoSplitInstance{\cmd}{\tbx@cmd@spt}{\tbx@cmd@rst}"\bracemeta{search}
+%\bracemeta{long}
+%   \end{quote}
+% creates the instance "\cmd" which splits its argument at
+% \bracemeta{search} (also "\tbx@cmd@spt" and "\tbx@cmd@rst" are created
+% which are needed for "\cmd" to work). The argument \meta{long} must be
+% either "\long" or empty, depending whether long definitions are desired.\par
+% The difficulty in the definition of "\cmd" is to ensure that "{xxx}|{yyy}"
+% splits into "{xxx}" and "{yyy}" \emph{with} braces (i.e., we have to
+% find out whether there are braces which are eliminated by \TeX\ as
+% `argument braces'). Actually, this problem occurs only for the part "{yyy}".
+% We solve it by appending an "a" to \meta{argument}, i.e., we actually
+% split the string "{xxx}|{yyy}a". Of course, we have to eliminate the
+% trailing "a" at the end.
+%    \begin{macrocode}
+\long\def\tbx@DoSplitInstance#1#2#3#4#5{%
+  #5\def#1##1##2##3{%
+    #2##2##3\toolboxEmpty##1#4#4@tbx@spt%
+    \ifx##3\toolboxEmpty
+      \let##3\undefined
+    \else
+      #3##3##1a@tbx@rst%
+    \fi
+  }%
+  #5\def#2##1##2##3#4##4#4##5@tbx@spt{\expandafter
+    \toolboxTokDef\expandafter{##3}##1\toolboxTokDef{##5}##2}%
+  #5\def#3##1##2#4##3@tbx@rst{\tbx@rememberlasta##3@tbx@dropa%
+    \tbx@defwithoutlasta##1##3@tbx@dropa}}
+%    \end{macrocode}
+%   \begin{macro}{\tbx@rememberlasta}
+% The call
+%    \begin{quote}
+%    "\tbx@rememberlasta"\meta{arg}"@tbx@dropa"
+%    \end{quote}
+% (no braces: The magic string "@tbx@dropa" is used to find the end of
+% \meta{arg}) is only admissible, if the last token in \meta{arg} is an "a".
+% In this case, \DescribeMacro{\tbx@droplasta}"\tbx@droplasta" is
+% defined as \meta{arg} without the trailing "a" (but it may happen that
+% \meta{arg} looses surrounding braces), and the corresponding string with the
+% trailing "a" (possibly without surrounding braces) is saved into
+% \DescribeMacro{\tbx@rebuilda}"\tbx@rebuilda".
+% This macro is used by the instances created
+% by "\tbx@DoSplitInstance".
+%    \begin{macrocode}
+\long\def\tbx@rememberlasta#1a@tbx@dropa{\toolboxTokDef{#1}\tbx@droplasta
+  \toolboxTokDef{#1a}\tbx@rebuilda}
+%    \end{macrocode}
+%   \end{macro}
+%   \begin{macro}{\tbx@defwithoutlasta}
+% The call
+%    \begin{quote}
+%    "\tbx@defwithoutlasta{\afterstring}"\meta{arg}"@tbx@dropa"
+%    \end{quote}
+% (no braces: The magic string "@tbx@dropa" is used to find the end of
+% \meta{arg}) is only admissible, if the last token in \meta{arg} is an "a".
+% If \meta{arg} coincides with "\tbx@rebuilda",
+% then we know that we did not loose any braces, and we set "\afterstring"
+% to the content of "\tbx@droplasta"; otherwise we lost braces and thus
+% have additionally to surround the content of "\afterstring" by braces.
+%    \begin{macrocode}
+\long\def\tbx@defwithoutlasta#1#2@tbx@dropa{\toolboxTokDef{#2}\tbx@originala
+  \ifx\tbx@originala\tbx@rebuilda
+%    \end{macrocode}
+% Did we forget braces in "\tbx@rememberlasta"?
+%    \begin{macrocode}
+    \let#1\tbx@droplasta
+  \else
+    \expandafter\toolboxTokDef\expandafter{\expandafter{\tbx@droplasta}}#1%
+  \fi}
+
+%    \end{macrocode}
+%   \end{macro}
+%  \end{macro}
+% \end{macro}
+% \begin{macro}{\toolboxFreeSplit}\nocomment
+%    \begin{macrocode}
+\def\toolboxFreeSplit#1{%
+  \tbx@SplitNames{#1}%
+  \expandafter
+    \toolboxLoop\expandafter{\tbx@splt}\tbx@freeSplit}
+%    \end{macrocode}
+%  \begin{macro}{\tbx@freeSplit}\nocomment
+%    \begin{macrocode}
+\def\tbx@freeSplit#1{\let#1\undefined}
+
+%    \end{macrocode}
+%  \end{macro}
+% \end{macro}
+% \begin{macro}{\toolboxSplitAt}
+%  "\toolboxSplitAt" just calls "tbx@DoSplitInstance" with dummy temporary
+%  variables and then executes the corresponding command.
+%    \begin{macrocode}
+\def\toolboxSplitAt{\toolboxIfNextGobbling*\tbx@SplitLong\tbx@SplitShort}
+%    \end{macrocode}
+%  \begin{macro}{\tbx@SplitLong}\nocomment
+%    \begin{macrocode}
+\long\def\tbx@SplitLong#1#2#3#4{%
+  \tbx@DoSplitInstance\tbx@splt\tbx@splta\tbx@spltb{#2}\long
+  \tbx@splt{#1}{#3}{#4}}
+%    \end{macrocode}
+%  \end{macro}
+%  \begin{macro}{\tbx@SplitShort}
+%    We cannot use just an additional argument in "\tbx@SplitLong", because
+%    we really should use a non-"\long" macro to read the arguments.
+%    \begin{macrocode}
+\def\tbx@SplitShort#1#2#3#4{%
+  \tbx@DoSplitInstance\tbx@splt\tbx@splta\tbx@spltb{#2}{}%
+  \tbx@splt{#1}{#3}{#4}}
+
+%    \end{macrocode}
+%  \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\toolboxReplaceSplit}
+%    "\toolboxReplaceSplit"\bracemeta{replace}"\SplitCmd\macro"
+%    \begin{macrocode}
+\long\def\toolboxReplaceSplit#1#2#3{%
+  \toolboxTokDef{#1}\tbx@reptext
+  \expandafter
+    \tbx@replace\expandafter{#3}{\let#3\toolboxEmpty}#3#2\tbx@reptext}
+%    \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\tbx@replace}
+%    "\tbx@replace\bracemeta{text}\bracemeta{first}\macro\SplitCmd\Reptext"
+%    First executes \meta{first}.
+%    Then appends to "\macro" the content of \bracemeta{text} with the matches
+%    of "\SplitCmd" replaced by the content of "\Reptext".
+%    \begin{macrocode}
+\long\def\tbx@replace#1#2#3#4#5{#2%
+  #4{#1}\tbx@repla\tbx@replb
+  \toolboxIfElse{\ifx\tbx@replb\undefined}%
+    {\toolboxDef#3{#3\tbx@repla}}%
+    {\toolboxDef#3{#3\tbx@repla#5}%
+     \expandafter\tbx@replace\expandafter{\tbx@replb}{}#3#4#5}}
+%    \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\toolboxReplace}
+%    "\toolboxReplace"\bracemeta{search}\bracemeta{replace}"\macro"
+%    just calls "tbx@DoSplitInstance" with dummy temporary variables
+%    and then executes "\toolboxReplaceSplit".
+%    \begin{macrocode}
+\long\def\toolboxReplace#1#2{%
+  \tbx@DoSplitInstance\tbx@splt\tbx@splta\tbx@spltb{#1}\long
+  \toolboxReplaceSplit{#2}\tbx@splt}
+%    \end{macrocode}
+% \end{macro}
+%
+% \subsection{Macros supporting redefinition of macros}
+%
+% \begin{macro}{\toolboxMakeHarmless}\nocomment
+%    \begin{macrocode}
+\def\toolboxMakeHarmless#1{\edef#1{\tbx@Nearverbatim#1}}
+%    \end{macrocode}
+%  \begin{macro}{\tbx@Nearverbatim}\nocomment
+%    \begin{macrocode}
+\def\tbx@Nearverbatim{\expandafter\tbx@Meaning\meaning}
+%    \end{macrocode}
+%  \end{macro}
+%  \begin{macro}{\tbx@Meaning}\nocomment
+%    \begin{macrocode}
+\long\def\tbx@Meaning#1>{}
+
+%    \end{macrocode}
+%  \end{macro}
+% \end{macro}
+%
+% \begin{macro}{\toolboxDropBrace}\nocomment
+%    \begin{macrocode}
+\def\toolboxDropBrace#1{\expandafter\tbx@ForgetBrace#1@tbx@dropbrace#1}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\tbx@ForgetBrace}\nocomment
+%    \begin{macrocode}
+\long\def\tbx@ForgetBrace#1@tbx@dropbrace#2{\toolboxTokDef{#1}#2}
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\toolboxIf}\nocomment
+%    \begin{macrocode}
+\long\def\toolboxIf#1#2#3{%
+  \ifx#1#3\def\tbx@tmp{#2#3}\else\def\tbx@tmp{#2\tbx@tmp}\fi\tbx@tmp}
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}{\toolboxNewiftrue}\nocomment
+%    \begin{macrocode}
+\def\toolboxNewiftrue#1{\tbx@newifexec{#1}{\csname#1true\endcsname}}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxNewiffalse}\nocomment
+%    \begin{macrocode}
+\def\toolboxNewiffalse#1{\tbx@newifexec{#1}{\csname#1false\endcsname}}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxNewiftrue}\nocomment
+%    \begin{macrocode}
+\def\toolboxNewifTrue#1{\tbx@newifexec{#1}{}\csname#1true\endcsname}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxNewiffalse}\nocomment
+%    \begin{macrocode}
+\def\toolboxNewifFalse#1{\tbx@newifexec{#1}{}\csname#1false\endcsname}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\tbx@newifexec}
+% \begin{quote}
+%  "\tbx@newifexec"\bracemeta{name}\bracemeta{initialization}
+% \end{quote}
+% If the command "\if"\meta{name} already exists, nothing happens.
+% Otherwise, the commands \cmdmeta{name}"true" and \cmdmeta{name}"false" are
+% created (similarly as by the \TeX\ command "\newif"), and afterwards
+% \meta{initialization} is executed. Here, \meta{initialization} should be
+% either \cmdmeta{name}"true" or \cmdmeta{name}"false"
+% which then defines "\if"\meta{name} to the desired default.
+% (It may also be empty if you do this initialization immediately afterwards).
+% \meta{initialization} should not contain any potential "\if" tokens.\par
+% One must be very careful in the implementation of this macro,
+% because "\if"'s are parsed very strange by \TeX.
+% However, if an "\if"-command is the first token following our only "\ifx",
+% we do not run into problems. Moreover, the first parsing until "\fi" does
+% not see any further "\if", because it is hidden in "\csname" which has not
+% been expanded by this time.
+%    \begin{macrocode}
+\def\tbx@newifexec#1#2{\expandafter
+   \ifx\csname if#1\endcsname\relax
+     \expandafter\tbx@newif\csname if#1\endcsname{#1}%
+     #2%
+   \fi}
+%    \end{macrocode}
+%  \begin{macro}{\tbx@newif}
+%  It is rather annoying that D.~E. Knuth has introduced the "\outer"
+%  directive:
+%  The sole purpose of that command is to cause problems and to force people
+%  to think how to get around these problems. It is especially irritating that
+%  the standard command "\newif" was (before \LaTeXe) defined with this
+%  attribute. To work in a normal way, we have to define "\newif" by hand
+%  in a sane way. It is simpler for us, if we do not only pass the name as a
+%  single token but additionally also the full name without "if".
+%  So our simpler "\newif" macro is called as follows:
+%  \begin{quote}
+%  "\tbx@newif"\cmdmeta{ifname}\bracemeta{name}
+%  \end{quote}
+%  This macro does \emph{not} define \cmdmeta{ifname}. But gets automatically
+%  defined after the first call of \cmdmeta{name}"true" or
+%  \cmdmeta{name}"false" which should of course happen immediately afterwards.
+%    \begin{macrocode}
+\def\tbx@newif#1#2{%
+  \expandafter
+    \def\csname#2true\endcsname{\let#1\iftrue}%
+  \expandafter
+    \def\csname#2false\endcsname{\let#1\iffalse}}
+
+%    \end{macrocode}
+%  \end{macro}
+% \end{macro}
+%
+% \subsection{Macros supporting concatenated macro names}
+%
+% \begin{macro}{\toolboxWithNr}\nocomment
+%    \begin{macrocode}
+\def\toolboxWithNr#1#2#3{\expandafter#2\csname #3#1\endcsname}
+%    \end{macrocode}
+% \end{macro}
+% \begin{macro}{\toolboxLet}\nocomment
+%    \begin{macrocode}
+\def\toolboxLet#1#2{\expandafter\let\expandafter#1\csname #2\endcsname}
+
+%    \end{macrocode}
+% \end{macro}
+%
+% \iffalse
+%</package>
+% \fi
+% \Finale\PrintIndex
+%
+%
+%
+% \iffalse
+%<*metainfo>
+% \fi
+\iffalse -------------------------------------------------------------
+%
+% Just in case that for some reason the file `toolbox.ins' got lost:
+% The content of this file is between the lines %<*insfile> and %</insfile>.
+%
+%\iffalse
+%</metainfo>
+%<*insfile>
+\def\batchfile{toolbox.ins}
+\input docstrip.tex
+\keepsilent
+\nopreamble
+\generateFile{toolbox.sty}{f}{\from{toolbox.dtx}{package}}
+\generateFile{toolbox.txt}{f}{\from{toolbox.dtx}{asciidocu}}
+\generateFile{toolbox.tex}{f}{\from{toolbox.dtx}{driver}}
+%%\generateFile{toolbox.ins.dup}{f}{\from{toolbox.dtx}{insfile}}
+
+\Msg{***************************************************************}
+\Msg{*}
+\Msg{* To finish the installation you have to move the}
+\Msg{* file 'toolbox.sty' into a directory searched by TeX.}
+\Msg{*}
+\Msg{*}
+\Msg{* Run the file toolbox.tex through LaTeX to produce the}
+\Msg{* documentation or read the ascii documentation in toolbox.txt}
+\Msg{*}
+\Msg{*}
+\Msg{***************************************************************}
+\endbatchfile
+%</insfile>
+%<*metainfo>
+% \fi
+\fi
+% \iffalse
+%</metainfo>
+% \fi
+\endinput
+
+%%% Local Variables: 
+%%% mode: latex
+%%% TeX-master: "toolbox.tex"
+%%% End: 
diff --git a/Master/texmf-dist/source/latex/toolbox/toolbox.ins b/Master/texmf-dist/source/latex/toolbox/toolbox.ins
new file mode 100644
index 00000000000..9032400b2af
--- /dev/null
+++ b/Master/texmf-dist/source/latex/toolbox/toolbox.ins
@@ -0,0 +1,22 @@
+\def\batchfile{toolbox.ins}
+\input docstrip.tex
+\keepsilent
+\nopreamble
+\generateFile{toolbox.sty}{f}{\from{toolbox.dtx}{package}}
+\generateFile{toolbox.txt}{f}{\from{toolbox.dtx}{asciidocu}}
+\generateFile{toolbox.tex}{f}{\from{toolbox.dtx}{driver}}
+%%\generateFile{toolbox.ins.dup}{f}{\from{toolbox.dtx}{insfile}}
+
+\Msg{***************************************************************}
+\Msg{*}
+\Msg{* To finish the installation you have to move the}
+\Msg{* file 'toolbox.sty' into a directory searched by TeX.}
+\Msg{*}
+\Msg{*}
+\Msg{* Run the file toolbox.tex through LaTeX to produce the}
+\Msg{* documentation or read the ascii documentation in toolbox.txt}
+\Msg{*}
+\Msg{*}
+\Msg{***************************************************************}
+\endbatchfile
+%</insfile>