summaryrefslogtreecommitdiff
path: root/Master/texmf-dist/source/latex/cprotect
diff options
context:
space:
mode:
Diffstat (limited to 'Master/texmf-dist/source/latex/cprotect')
-rw-r--r--Master/texmf-dist/source/latex/cprotect/cprotect.dtx634
-rw-r--r--Master/texmf-dist/source/latex/cprotect/cprotect.ins71
2 files changed, 705 insertions, 0 deletions
diff --git a/Master/texmf-dist/source/latex/cprotect/cprotect.dtx b/Master/texmf-dist/source/latex/cprotect/cprotect.dtx
new file mode 100644
index 00000000000..d8bc5495d28
--- /dev/null
+++ b/Master/texmf-dist/source/latex/cprotect/cprotect.dtx
@@ -0,0 +1,634 @@
+% \iffalse meta-comment
+%<*internal>
+\iffalse
+%</internal>
+%<*readme>
+----------------------------------------------------------------
+cprotect --- verbatim in macro arguments
+E-mail: bruno@le-floch.fr
+Released under the LaTeX Project Public License v1.3c or later
+See http://www.latex-project.org/lppl.txt
+----------------------------------------------------------------
+
+A user of the cprotect.sty package can include verbatim text (\verb,
+verbatim environment, ...) in the argument of any command,
+including moving arguments. Including verbatim text in footnotes,
+section titles (and other titles), etc. is as simple as typing
+`\cprotect\footnote` instead of `\footnote`, etc.
+
+A similar approach is taken for environments. Nesting of the
+various environments is taken into account.
+
+This is work in progress, all comments/bug reports are welcome!
+
+
+The whole package can be built from the file `cprotect.dtx' by running
+
+pdflatex cprotect.dtx
+makeindex -s gglo.ist -o cprotect.gls cprotect.glo
+makeindex -s gind.ist -o cprotect.ind cprotect.idx
+pdflatex cprotect.dtx
+pdflatex cprotect.dtx
+mv README.txt README
+
+The first run of pdflatex produces `cprotect.ins', `cprotect.sty',
+`cprotect.pdf', and this file. The other commands are necessary for
+the pdf to contain its index and glossary.
+
+
+%</readme>
+%<*internal>
+\fi
+\def\nameofplainTeX{plain}
+\ifx\fmtname\nameofplainTeX\else
+ \expandafter\begingroup
+\fi
+%</internal>
+%<*install>
+\input docstrip.tex
+\keepsilent
+\askforoverwritefalse
+\preamble
+----------------------------------------------------------------
+cprotect --- verbatim in macro arguments
+E-mail: bruno@le-floch.fr
+Released under the LaTeX Project Public License v1.3c or later
+See http://www.latex-project.org/lppl.txt
+----------------------------------------------------------------
+
+\endpreamble
+\postamble
+
+Copyright (C) 2010 by Bruno Le Floch <bruno@le-floch.fr>
+
+This work may be distributed and/or modified under the
+conditions of the LaTeX Project Public License (LPPL), either
+version 1.3c of this license or (at your option) any later
+version. The latest version of this license is in the file:
+
+http://www.latex-project.org/lppl.txt
+
+This work is "maintained" (as per LPPL maintenance status) by
+Bruno Le Floch.
+
+This work consists of the file cprotect.dtx
+and the derived files cprotect.ins,
+ cprotect.pdf and
+ cprotect.sty.
+
+\endpostamble
+\usedir{tex/latex/cprotect}
+\generate{
+ \file{\jobname.sty}{\from{\jobname.dtx}{package}}
+}
+%</install>
+%<install>\endbatchfile
+%<*internal>
+\usedir{source/latex/cprotect}
+\generate{
+ \file{\jobname.ins}{\from{\jobname.dtx}{install}}
+}
+\nopreamble\nopostamble
+\usedir{doc/latex/cprotect}
+\generate{
+ \file{README.txt}{\from{\jobname.dtx}{readme}}
+}
+\ifx\fmtname\nameofplainTeX
+ \expandafter\endbatchfile
+\else
+ \expandafter\endgroup
+\fi
+%</internal>
+%<*package>
+\NeedsTeXFormat{LaTeX2e}
+\ProvidesPackage{cprotect}[2010/12/30 v1.0 (Bruno Le Floch)]
+%</package>
+%<*driver>
+\documentclass[12pt]{ltxdoc}
+\usepackage[T1]{fontenc}
+\usepackage{cprotect}
+\usepackage{amsmath}
+\usepackage[margin=4cm]{geometry}
+\usepackage{hyperref}
+\EnableCrossrefs
+\CodelineIndex
+\RecordChanges
+\begin{document}
+ \DocInput{cprotect.dtx}
+\end{document}
+%</driver>
+% \fi
+%
+% \CheckSum{244}
+%
+%
+%\GetFileInfo{cprotect.sty}
+%
+%\DoNotIndex{\addtocounter,\advance,\afterassignment,\aftergroup,\arabic}
+%\DoNotIndex{\begingroup,\closeout,\count,\csname,\def,\edef,\gdef,\else}
+%\DoNotIndex{\endcsname,\endgroup,\expandafter,\fi,\ifnum,\ifthenelse,\ifx}
+%\DoNotIndex{\immediate,\indexspace,\let,\newcommand,\newcounter,\newwrite}
+%\DoNotIndex{\openout,\relax,\repeat,\RequirePackage,\setcounter,\string}
+%\DoNotIndex{\stepcounter,\value,\WithSuffix,\(,\),\+,\/,\=,\@gobble}
+%\DoNotIndex{\{}
+%\DoNotIndex{\}}
+%\DoNotIndex{\^}
+%
+%\cprotect\title{|{cprotect.sty}|\\
+% |\verb|atim in |\macro| arguments\thanks{This file
+% describes version \fileversion, last revised \filedate.}}
+%\author{Bruno Le Floch\thanks{E-mail: bruno@le-floch.fr}}
+%\date{Released \filedate}
+%
+%\maketitle
+%
+% \tableofcontents
+% \changes{v1.0}{2010/12/30}{First version with documentation}
+%
+%
+%
+% \cprotect\section{Include \verb-\verb- anywhere!}
+% \label{sec:intro}
+%
+% The |cprotect| package will allow you to put verbatim in
+% footnotes\cprotect\footnote{Like this: \verb-!@#$%^&*()_+-.}
+% in a straightforward way. The section above was typeset using
+% \begin{verbatim}
+% \cprotect\section{Include\verb-\verb- anywhere!}\end{verbatim}
+% and the footnote was
+% \begin{verbatim}
+% ...tes\cprotect\footnote{Like this: \verb-!@#$%^&*()_+-.}\end{verbatim}
+%
+% More generally, let us assume that you want to use verbatim text in
+% the argument of some macro |\cs| \marg{arg1}, and that this
+% macro is normally allergic to verbatim. It probably has a good reason
+% to be allergic, but using an auxiliary file, we can solve the problem
+% entirely: if you want \marg{arg1} to contain verbatim, just write
+% |\cprotect\cs| or |\cprotect{\cs}| instead of |\cs|.\cprotect\footnote{This
+% solves most problems, for instance, verbatim text in section titles
+% written as |\cprotect\section|\marg{title} appears correctly in the table
+% of contents. However, there are still bugs in capitalized headers.}
+% All the examples I give use very standard macros, but it should work
+% with any macro.\cprotect\footnote{If you have a macro that works when it is not
+% preceeded by |\cprotect|, but breaks down if you put |\cprotect| in front of
+% it, I will be interested to know why.}
+%
+% Braces are useful if a macro has \emph{several} arguments, and you want
+% to put verbatim in the second one: then type
+% |\cprotect{\cs|\marg{arg1}|}|\marg{arg2}. If you want to put verbatim in
+% both arguments, well \ldots\ it is not implemented yet, but if you send
+% me an email saying why you need it, I will look into it (suggestions
+% are, as always, welcome).
+%
+%
+% \section{List of user commands}
+% \label{sec:commandlist}
+%
+% \DescribeMacro{\cprotect}
+% Possibly the single most useful command is |\cprotect|, used as
+% |\cprotect| |\foo| \marg{arg1} or |\cprotect| \marg{cslist} \marg{arg1}.
+% As described in the previous section, the first form behaves as
+% |\foo| \marg{arg1}, and the second as \meta{cslist} \marg{arg1}.
+% The difference is that the argument \marg{arg1} can now contain
+% |\catcode| changes (e.g., induced by the |\verb| command and the
+% |verbatim| environment). In fact, \marg{arg1} is written to a file, and
+% then read again as the argument of |\foo|. So using |\cprotect|, one could
+% in principle build weird macros that read their arguments several times,
+% with different |\catcodes| in effect each time. The macro
+% |\ReadVerbatimUntil| below gives a better way of doing that.
+%
+% \DescribeMacro{\cMakeRobust}
+% If you find yourself using a |\cprotect\foo| combination frequently, you
+% can simply define |\bar| to mean |\cprotect\foo|. It should work at least
+% most of the time. You can also use the typical
+% \begin{verbatim}
+% \let\oldfoo\foo
+% \def\foo{\cprotect\oldfoo}\end{verbatim}
+% to redefine |\foo| itself instead of a new command |\bar|. The package
+% provides a wrapper for this construction: |\cMakeRobust\foo| replaces |\foo|
+% by a version which accepts verbatim. As a stupid example,
+% \begin{verbatim}
+% \newcommand{\expon}[1]{\mathrm{#1}^{#1}}
+% \cMakeRobust{\expon}
+% \(\expon{Hel\verb+|+o}\)\end{verbatim}
+% produces
+% \newcommand{\expon}[1]{\mathrm{#1}^{#1}}
+% \cMakeRobust{\expon}
+% \(\expon{Hel\verb+|+o}\), and the verbatim is treated correctly.
+%
+% \DescribeMacro{\cprotEnv}
+% Something similar to |\cprotect| exists for environments: |\cprotEnv|. Simply
+% put |\cprotEnv| |\body| \marg{name} instead of |\body| \marg{name}. For
+% example,
+% \begin{verbatim}
+% \cprotEnv\begin{align}
+% x&=\begin{cases}
+% 1 &\text{if }\verb"@#%^&*"\\
+% 2 &\text{otherwise}
+% \end{cases}
+% \end{align}\end{verbatim}
+% gives
+% \cprotEnv\begin{align}
+% x&=\begin{cases}
+% 1 &\text{if }\verb"@#%^&*"\\
+% 2 &\text{otherwise}
+% \end{cases}
+% \end{align}
+% Note that unfortunately we need to put the |\verb| outside |\text|.
+% This is because currently, nesting of |\cprotect| and friends is not supported.
+%
+% You can use |\CPTbegin| as a short-hand for |\cprotEnv\begin|, but this will
+% fail when nesting the same environment twice: the inner nesting is
+% distinguished by \emph{precisely} the characters
+% \texttt{\textbackslash\ b e g i n \{ \emph{n a m e} \}}.
+%
+%
+% \DescribeMacro{\ReadVerbatimUntil}
+% Finally, the most powerful and the root of all these macros, from which
+% the package currently derives its name, is |\ReadVerbatimUntil|. The aim
+% of this command is to read a piece of text verbatim, until it reaches an
+% end-marker. It then writes all that it has read to an auxiliary file for
+% future use. The most naive approach has a major flaw when nesting is
+% involved: when parsing |{}}| for instance, with an end-marker of |}|, we
+% often wish to stop at the \emph{second} closing bracket, not the first one.
+% Thus, |\ReadVerbatimUntil| needs to be aware of a begin-marker. Also, for
+% some applications we need to write things before and after the content
+% read by |\ReadVerbatimUntil|. Finally, we want to do something once the
+% file has been written, and possibly something before.
+%
+% The syntax is thus |\ReadVerbatimUntil| \oarg{arg1} \marg{arg2}
+% |^begin|\-|text^end|\-|text^begin|\-|tag^end|\-|tag^|, followed by the text
+% in which we look for |endtag|. The caret (|^|) can be any character.
+% It delimits the four verbatim-like arguments of
+% |\ReadVerbatimUntil|. The strings of letters |begintext|
+% and |endtext| are pre- and ap-pended to the file. As mentionned before,
+% |begintag| and |endtag| are used when reading the content, to determine
+% how far |\ReadVerbatimUntil| should go. The mandatory argument
+% \marg{arg2} is executed once the whole text has been stored to a file.
+% Typically, \marg{arg2} involves reading the file one or more times,
+% and acting on it in any way we like. The optional argument is used for
+% hacks such as changing where |cprotect| writes his files.
+%
+%
+%
+% \section{Known bugs/limitations}
+% \label{sec:bugs}
+%
+% Incompatibility with |\pagestyle{headings}|: when a chapter title is put
+% as a header, it gets upper-cased. If you did |\cprotect\chapter{...}| as
+% usual, the title has been stored to a file, but now, the name of the file
+% is capitalized, and \TeX\ cannot find it.
+%
+% Issues with nesting of |\cprotect| in |align| environments: the issue seems
+% to arise because the |align| environment wants to fully expand it argument
+% once before typesetting it.
+%
+% For commands with two or more arguments, it is only possible to put verbatim
+% in one of the arguments (and the syntax is not great).
+%
+% The argument of any command that is prefixed with |\cprotect| has to have balanced
+% braces, \emph{even when hidden inside verbatim environments, or even comments}. For
+% instance,
+% \begin{verbatim}
+% \cprotect\footnote{On the \verb:{: character} \end{verbatim}
+% would fail: |\cprotect| would see the brace in |\verb:{:|, and count it
+% as an opening tag, which then has to be closed. This is most likely
+% to lead |\cprotect| to gobble the whole file before complaining. Similarly,
+% \begin{verbatim}
+% \cprotect\footnote{On the \verb:!: %should it be }?
+% character}\end{verbatim}
+% would only gobble until the closing brace in |%should it be }?|, and
+% I am not sure what error would be produced.
+%
+% But we can use one ailment to cure the other! A correct way to typeset
+% the first example is
+% \begin{verbatim}
+% \cprotect\footnote{On the \verb:{: character%}
+% } \end{verbatim}
+% if |%| is a comment character at the time it is read. A safer solution
+% would be to use |\iffalse}\fi| instead of |%}|. It still requires to
+% be sure that |\| is an escape character when this piece of code is read,
+% and can lead to problems if the previous token is |\let| for instance.
+%
+%
+%
+% \section{The code}
+% \label{sec:code}
+%
+%\StopEventually{\clearpage\PrintChanges\PrintIndex}
+%
+% \begin{macrocode}
+%<*package>
+% \end{macrocode}
+%
+% \subsection{Setting up}
+%
+% We first load a few packages
+% \begin{macrocode}
+\RequirePackage{ifthen}
+\RequirePackage{suffix}
+% \end{macrocode}
+%
+% Then we introduce the commands pertaining to writing
+% files.\footnote{To be rewritten. For the moment, we use a new file
+% each time cprotect is used. Thus, many files. But this is needed if
+% people want to nest cprotect's.}
+%
+% We write files |\jobname-1.cpt|, |\jobname-2.cpt|, etc. in order.
+% \begin{macrocode}
+\newwrite\CPT@WriteOut
+\newcounter{CPT@WriteCount}
+\newcommand{\CPT@Write}[1]{%
+ \stepcounter{CPT@WriteCount}%
+ \immediate\openout\CPT@WriteOut=\jobname-%
+ \arabic{CPT@WriteCount}.cpt%
+ \newlinechar`\^^M%
+ \immediate\write\CPT@WriteOut{#1}%
+ \immediate\closeout\CPT@WriteOut%
+ \aftergroup\CPT@setLastFileName%
+}
+\newcommand{\CPT@setLastFileName}{%
+ \def\CPT@lastFileName{\jobname-\arabic{CPT@WriteCount}.cpt}}
+\newcommand{\CPT@input@last}{%
+ \expandafter\protect\expandafter\input
+ \expandafter{\CPT@lastFileName}}
+% \end{macrocode}
+%
+%
+% The next command changes all catcodes to letters. It was adapted from
+% |filecontents.sty|.
+% \begin{macrocode}
+\newcommand{\makeallletters}{%
+ \count0=0\relax %
+ \loop %
+ \catcode\count0=11\relax %
+ \advance\count0 by 1\relax %
+ \ifnum\count0<256 %
+ \repeat %
+}
+% \end{macrocode}
+%
+%
+% \cprotect\subsection{|\ReadVerbatimUntil|}
+% Both |\ReadVerbatimUntil| and its starred version (which we define using
+% the |suffix.sty| package) take one optional argument \oarg{first-cs} and
+% a mandatory argument \marg{final-cs}. The \meta{final-cs} is saved as
+% |\CPT@commandatend| to be executed when we close the file (and the
+% group).\cprotect\footnote{It is not a straightforward |\aftergroup|,
+% because I want this to be executed after another |\aftergroup| that
+% comes later.}
+% \begin{macrocode}
+\newcommand\ReadVerbatimUntil[2][]{%
+ \def\CPT@commandatend{#2}%
+ \begingroup #1%
+ \makeallletters%
+ \CPT@setup}
+\WithSuffix\newcommand\ReadVerbatimUntil*[2][]{%
+ \def\CPT@commandatend{#2}%
+ \begingroup #1%
+ \makeallletters%
+ \CPT@starsetup}
+% \end{macrocode}
+%
+% |\CPT@setup| reads the four ``verbatim'' arguments following
+% \marg{final-cs}, and stores them in this order as macros |\CPT@preText|,
+% |\CPT@postText|, |\CPT@begin|, and |\CPT@end|. The macros which read each
+% of these arguments need to be defined inside |\CPT@setup|, because
+% I don't want any constraint on the delimiter. I could write a single
+% macro that gobbles all four arguments at once, but this would require
+% a crazy number of |\expandafter|s, so instead I do it one by one.
+%
+% If the delimiter was given, say |^|, then we would define |\CPT@readBegin|
+% as |\def \CPT@readBegin#1^{\def \CPT@begin{#1}\CPT@readEnd}|.
+% But since |^| is not given explicitly, we need |\expandafter|s to
+% expand it before the definition takes place. To avoid code repetition,
+% I did it once and for all in the auxiliary macro |\CPT@def|. Note that
+% a parameter of |##1| is somehow hidden inside |\CPT@def|, and that the
+% |##1| inside the replacement text refer to the arguments of the
+% |\CPT@read...| macros.
+% \begin{macrocode}
+\newcommand{\CPT@def}[2]{\expandafter\def\expandafter#1%
+ \expandafter##\expandafter1#2}
+\newcommand{\CPT@setup}[1]{%
+ \def\CPT@delimiter{#1}%
+ \CPT@def\CPT@readPreText\CPT@delimiter{%
+ \def\CPT@preText{##1}\CPT@readPostText}%
+ \CPT@def\CPT@readPostText\CPT@delimiter{%
+ \def\CPT@postText{##1}\CPT@readBegin}%
+ \CPT@def\CPT@readBegin\CPT@delimiter{%
+ \def\CPT@begin{##1}\CPT@readEnd}%
+ \CPT@def\CPT@readEnd\CPT@delimiter{%
+ \def\CPT@end{##1}\CPT@readContent}%
+ \CPT@readPreText%
+}
+\newcommand{\CPT@starsetup}[1]{\CPT@setup#1#1#1}
+% \end{macrocode}
+% We also give the variant |\CPT@starsetup|, which has empty
+% |\CPT@preText| and |\CPT@postText|.
+%
+% When |\CPT@setup| is expanded, it will call |\CPT@|\-|readPreText|,
+% |\CPT@|\-|readPostText|, |\CPT@|\-|readBegin|, and |\CPT@|\-|readEnd|,
+% and finish with |\CPT@|\-|readContent|, which we describe now.
+%
+%
+% We borrow the idea of quark from |expl3|: |\CPT@qend| expands to
+% itself, useful for |\ifx| comparisons. The counter |CPT@numB| will count
+% the surplus of |begin-tag|s compared to |end-tag|s when we parse the text
+% following |\CPT@readContent|. And |\CPT@store| is a macro that adds its
+% argument to an other macro (I was too lazy to learn about token lists).
+% The storage itself will be initialized later.
+% \begin{macrocode}
+\def\CPT@qend{\CPT@qend}
+\newcounter{CPT@numB}
+\newcommand{\CPT@store}[1]{\edef\CPT@storage{\CPT@storage#1}}
+% \end{macrocode}
+%
+% The macro |\CPT@readContent| is quite tricky: if the |begin-tag| and
+% |end-tag| were one character, things would be easy: I would read one
+% character at a time, and compare it to both |begin-tag| and |end-tag|,
+% then either store it, and possibly increase or decrease |CPT@numB|, or
+% decide that I am done if |CPT@numB| becomes negative.
+%
+% Unfortunately, I want to use |\ReadVerbatimUntil| for environments, in
+% which case the |begin-tag| is |\begin{myenv}| and the |end-tag| is
+% |\end{myenv}|. So two options:
+% \begin{itemize}
+% \item code a standard string searching algorithm... I did not feel
+% like it, but it might lead to a regexp package later on;
+% \item use \TeX's delimited parameters.
+% \end{itemize}
+% I did the latter, using |\CPT@def| again (we want to expand the string
+% which delimits the parameter before doing the definition).
+%
+% The details are ugly:
+% \begin{itemize}
+% \item gobble until the first |end-tag|,\cprotect\footnote{This will fail for
+% devious cases: if |begin-tag| is |abc| and |end-tag| is |bcd|, and
+% |\CPT@readContent| is followed by |abcd...|: we will wrongly see
+% |bcd| as an |end-tag|.} and insert a fake |begin-tag|, as well as the
+% quark guard |\CPT@qend|,
+% \item inside what we gobbled, gobble |begin-tag|s until reaching the fake
+% one (marked by the quark guard).
+% \item continue until we have one more |end-tag| than |begin-tag|.
+% \end{itemize}
+% \begin{macrocode}
+\newcommand{\CPT@readContent}{%
+ \CPT@def\CPT@gobbleOneB\CPT@begin##2{%
+ \ifx\CPT@qend##2\CPT@store{##1}\addtocounter{CPT@numB}{-1}%
+ \else\CPT@store{##1\CPT@begin}\stepcounter{CPT@numB}%
+ \expandafter\CPT@gobbleOneB\expandafter##2\fi}%
+ %
+ \CPT@def\CPT@gobbleUntilE\CPT@end{%
+ \edef\CPT@tempi{##1\CPT@begin}%
+ \expandafter\CPT@gobbleOneB\CPT@tempi\CPT@qend%
+ \ifthenelse{\value{CPT@numB}<0}{%
+ \CPT@store{\CPT@postText}%
+ \CPT@Write{\CPT@storage}\endgroup%
+ \CPT@commandatend%
+ }{%
+ \CPT@store{\CPT@end}\CPT@gobbleUntilE%
+ }%
+ }%
+ \setcounter{CPT@numB}{0}%
+ \def\CPT@storage{\CPT@preText}%
+ \CPT@gobbleUntilE%
+}
+% \end{macrocode}
+%
+%
+% \cprotect\subsection{For macros: |\cprotect| and friends}
+%
+% Equipped with |\ReadVerbatimUntil|, we are ready for the more practical
+% macros. |\cprotect| cheats: it uses |{| and |}| as a |begin-tag| and |end-tag|.
+% This works most of the time, but fails in cases such as those presented in
+% Section~\ref{sec:bugs} (in usual cases there are
+% workarounds\cprotect\footnote{But I could definitely not have the contents of
+% this |.dtx| file as a (huge) footnote in some document: since |{| and |}|
+% change |\catcode|s, it is unlikely that the numbers balance correctly.}).
+%
+% The first argument of |\cprotect| is the control sequence |\cs| that we are
+% patching.
+% \begin{macrocode}
+\newcommand{\cprotect}[1]{\def\CPT@cs{#1}%
+ \afterassignment\CPT@A\let\CPT@next}
+% \end{macrocode}
+% Then, we check whether the next token is a brace or not:
+% \begin{itemize}
+% \item If it is, we discard the |{|, and the argument of |\cs| stops
+% at the matching explicit closing brace |}|. (See |\CPT@n{| below...
+% yes, the name of the control sequence does contain the brace,
+% which is simply a letter, after all.)
+% \item If it is not, the argument of |\cs| is this token only: we insert
+% a brace after the token, and launch |\ReadVerbatimUntil|. Think of this
+% as inserting braces around the argument, and doing what we did in the
+% former case: discarding the opening brace. (See |\CPT@N| below.)
+% \end{itemize}
+%
+% Since |\ReadVerbatimUntil| makes everything into letters, we need braces
+% to be letters when we define most macros in this Section. We thus need
+% a few |\catcode| changes. Think of \(|{|\to|(|\) and \(|}|\to|)|\).
+% \begin{macrocode}
+\begingroup
+ \catcode`\{=11 \catcode`\}=11 \catcode`\+=11
+ \catcode`\(=1 \catcode`\)=2
+ \gdef\CPT@A(%
+ \ifx\CPT@next\bgroup%
+ \expandafter\CPT@n{%
+ \else%
+ \expandafter\CPT@N%
+ \fi)
+ \gdef\CPT@n{(\ReadVerbatimUntil*(%
+ \CPT@cs(\CPT@input@last))+{+}+)%
+ \gdef\CPT@N(\expandafter\CPT@n{\CPT@next })%
+\endgroup
+% \end{macrocode}
+% Note the use of |\bgroup| in |\CPT@A|: if the argument of |\cs| starts
+% with an opening brace, it has been read early, and its |\catcode| will
+% still be |1|.\cprotect\footnote{I am not sure whether catcodes really matter
+% in such an |\ifx|.}
+%
+% We use |+| as a delimiter for |\ReadVerbatimUntil|. No |begin-text|
+% nor |end-text|. |begin-tag| and |end-tag| are |{| and |}| as mentionned
+% before.
+%
+% Once the matching |}| is found, we apply |\CPT@cs| (|\cs| stored) to
+% |\CPT@input@last|, aka the file where we saved the argument
+% (we add some protection so that things work well in |\section| and
+% similar situations).
+%
+% Finally, the |\cMakeRobust| command is a mess, and could probably be improved,
+% although... it works |:)|.
+% \begin{macrocode}
+\newcommand{\cMakeRobust}[1]{%
+ \def\CPT@cs@name{\expandafter\@gobble\string#1}%
+ \expandafter\let\csname CPT@old@\CPT@cs@name\endcsname #1%
+ \expandafter\def\csname\CPT@cs@name\endcsname{%
+ \expandafter\cprotect\csname CPT@old@\CPT@cs@name\endcsname}%
+}
+% \end{macrocode}
+%
+%
+% \cprotect\subsection{For Environments: |\cprotEnv\begin| and |\CPTbegin|}
+%
+% \DescribeMacro{\CPTbegin}
+% We introduce the command |\CPTbegin|, which has a behaviour close to
+% the behaviour of |\begin|. Namely, |\CPTbegin{env}| gobbles its argument
+% until it sees the matching |\end|, and it writes what it gobbled to
+% a file. It then inputs the file between |\begin{...}| and |\end{...}|,
+% as we can see from the definition of |\CPT@commandatend|.
+%
+% As for the case of |\cprotect|, we need to setup the values of the four
+% arguments of |\ReadVerbatimUntil| before reading the content. Since
+% the |begin-tag| and |end-tag| depend on a parameter, it would be
+% incredibly messy to try to expandafter the right things, so we
+% define |\CPT@env@setup| to, well, setup the values of the four
+% arguments of |\ReadVerbatimUntil|, and then skip directly to
+% |\CPT@readContent|.
+%
+% \begin{macrocode}
+\newcommand{\CPTbegin}[1]{%
+ \def\CPT@commandatend{\begin{#1}\CPT@input@last\end{#1}}%
+ \begingroup%
+ \CPT@env@setup{#1}%
+ \makeallletters%
+ \CPT@readContent%
+}
+% \end{macrocode}
+%
+% As announced, |\CPT@env@setup|, defined with lots of catcode changes.
+% Since the catcode of |\| changes, I need an extra escape character,
+% which I take to be |/|. I use two groups so each group is opened and
+% closed using the same escape character (this is technically irrelevant,
+% but seems less messy).
+% \begin{macrocode}
+\begingroup\catcode`\/=0
+/begingroup/catcode`/\=11
+ /catcode`/{=11 /catcode`/}=11 /catcode`/-=11
+ /catcode`/(=1 /catcode`/)=2
+ /gdef/CPT@env@setup#1(%
+ /def/CPT@preText(\relax )%
+ /def/CPT@postText(\relax )%
+ /def/CPT@begin(\begin{#1})%
+ /def/CPT@end(\end{#1})%
+ )
+/endgroup
+\endgroup
+% \end{macrocode}
+%
+% A final piece of code is needed so that |\CPT|-environments can be
+% nested: in order to be able to nest, we need |\ReadVerbatimUntil|
+% to be aware that our environment has been opened when |\CPTbegin{foo}|
+% or |\begin{foo}| appear in the text. Given the rules for delimited
+% parameters in TeX, this is quite difficult. A workaround is to replace
+% |\CPTbegin| by something that ends in |\begin| shuch as |\cprotEnv\begin|
+% as defined below. Thus, for nesting to work, you need to prepend every
+% one of your |env| environments with |\cprotEnv|.
+% \begin{macrocode}
+\def\cprotEnv\begin{\CPTbegin}
+% \end{macrocode}
+%
+% \begin{macrocode}
+%</package>
+% \end{macrocode}
+%\Finale
+\endinput \ No newline at end of file
diff --git a/Master/texmf-dist/source/latex/cprotect/cprotect.ins b/Master/texmf-dist/source/latex/cprotect/cprotect.ins
new file mode 100644
index 00000000000..faa18f23a25
--- /dev/null
+++ b/Master/texmf-dist/source/latex/cprotect/cprotect.ins
@@ -0,0 +1,71 @@
+%%
+%% This is file `cprotect.ins',
+%% generated with the docstrip utility.
+%%
+%% The original source files were:
+%%
+%% cprotect.dtx (with options: `install')
+%% ----------------------------------------------------------------
+%% cprotect --- verbatim in macro arguments
+%% E-mail: bruno@le-floch.fr
+%% Released under the LaTeX Project Public License v1.3c or later
+%% See http://www.latex-project.org/lppl.txt
+%% ----------------------------------------------------------------
+%%
+\input docstrip.tex
+\keepsilent
+\askforoverwritefalse
+\preamble
+----------------------------------------------------------------
+cprotect --- verbatim in macro arguments
+E-mail: bruno@le-floch.fr
+Released under the LaTeX Project Public License v1.3c or later
+See http://www.latex-project.org/lppl.txt
+----------------------------------------------------------------
+
+\endpreamble
+\postamble
+
+Copyright (C) 2010 by Bruno Le Floch <bruno@le-floch.fr>
+
+This work may be distributed and/or modified under the
+conditions of the LaTeX Project Public License (LPPL), either
+version 1.3c of this license or (at your option) any later
+version. The latest version of this license is in the file:
+
+http://www.latex-project.org/lppl.txt
+
+This work is "maintained" (as per LPPL maintenance status) by
+Bruno Le Floch.
+
+This work consists of the file cprotect.dtx
+and the derived files cprotect.ins,
+ cprotect.pdf and
+ cprotect.sty.
+
+\endpostamble
+\usedir{tex/latex/cprotect}
+\generate{
+ \file{\jobname.sty}{\from{\jobname.dtx}{package}}
+}
+\endbatchfile
+%%
+%% Copyright (C) 2010 by Bruno Le Floch <bruno@le-floch.fr>
+%%
+%% This work may be distributed and/or modified under the
+%% conditions of the LaTeX Project Public License (LPPL), either
+%% version 1.3c of this license or (at your option) any later
+%% version. The latest version of this license is in the file:
+%%
+%% http://www.latex-project.org/lppl.txt
+%%
+%% This work is "maintained" (as per LPPL maintenance status) by
+%% Bruno Le Floch.
+%%
+%% This work consists of the file cprotect.dtx
+%% and the derived files cprotect.ins,
+%% cprotect.pdf and
+%% cprotect.sty.
+%%
+%%
+%% End of file `cprotect.ins'.