From d939f20185ca3eeb907009d125b3b6f8a69203c4 Mon Sep 17 00:00:00 2001 From: Karl Berry Date: Mon, 15 Aug 2016 20:38:41 +0000 Subject: phfparen (16aug16) git-svn-id: svn://tug.org/texlive/trunk@41859 c570f23f-e606-0410-a88d-b1316a301751 --- .../texmf-dist/source/latex/phfparen/phfparen.dtx | 781 +++++++++++++++++++++ .../texmf-dist/source/latex/phfparen/phfparen.ins | 55 ++ 2 files changed, 836 insertions(+) create mode 100644 Master/texmf-dist/source/latex/phfparen/phfparen.dtx create mode 100644 Master/texmf-dist/source/latex/phfparen/phfparen.ins (limited to 'Master/texmf-dist/source/latex/phfparen') diff --git a/Master/texmf-dist/source/latex/phfparen/phfparen.dtx b/Master/texmf-dist/source/latex/phfparen/phfparen.dtx new file mode 100644 index 00000000000..b746f6c51f7 --- /dev/null +++ b/Master/texmf-dist/source/latex/phfparen/phfparen.dtx @@ -0,0 +1,781 @@ +% \iffalse meta-comment +% +% Copyright (C) 2016 by Philippe Faist +% ------------------------------------------------------- +% +% This file may be distributed and/or modified under the +% conditions of the LaTeX Project Public License, either version 1.3 +% of this license or (at your option) any later version. +% The latest version of this license is in: +% +% http://www.latex-project.org/lppl.txt +% +% and version 1.3 or later is part of all distributions of LaTeX +% version 2005/12/01 or later. +% +% \fi +% +% \iffalse +%<*driver> +\ProvidesFile{phfparen.dtx} +% +%\NeedsTeXFormat{LaTeX2e}[2005/12/01] +%\ProvidesPackage{phfparen} +%<*package> + [2016/08/15 v1.0 phfparen package] +% +% +%<*driver> +\documentclass{ltxdoc} +\usepackage{xcolor} +\usepackage{phfqit} +\usepackage{amsmath} +\usepackage[backtickon]{phfparen} +\makeatletter +\providecommand\phfnote@pkgdoc@setupmainfont{ + \renewcommand{\rmdefault}{futs}% only rm font, not math +}\makeatother +\usepackage[preset=xpkgdoc]{phfnote} +\EnableCrossrefs +\CodelineIndex +\RecordChanges + +\verbdef\phfverbpren+\paren+ +\robustify\phfverbpren + +\begin{document} + \DocInput{phfparen.dtx} +\end{document} +% +% \fi +% +% \CheckSum{0} +% +% \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 \~} +% +% +% \changes{v1.0}{2016/04/20}{Initial version} +% +% \GetFileInfo{phfparen.dtx} +% +% \DoNotIndex{\newcommand,\newenvironment,\def,\gdef,\edef,\xdef,\if,\else,\fi,\ifx} +% +% \title{\phfqitltxPkgTitle{phfparen}} +% \author{Philippe Faist\quad\email{philippe.faist@bluewin.ch}} +% \date{\pkgfmtdate\filedate} +% \maketitle +% +% \begin{abstract} +% \pkgname{phfparen}---Parenthetic math expressions made simpler and less +% redundant. +% \end{abstract} +% +% \inlinetoc +% +% \section{Introduction} +% +% The \pkgname{phfparen} package provides an easier way to handle +% parenthetic expressions in math formulae, by reducing the amount of +% redundancy in the \LaTeX{} code. +% +% The basic command is |\paren|\hspace{0.25ex}\meta{optional size +% arg}\hspace{0.25ex}\meta{opening delimiter} \ldots{} \meta{closing +% delimiter}. It puts the given contents (``\ldots'') within the given +% delimiters (such as ``[...]'', ``(...)'' or ``\{...\}''), and where the +% delimiters are sized according to the default size (no argument), the +% explicitly given size argument (``|\big|''), or the automatic sizing +% (``|*|''). As a shorthand, you may use a backtick character (``|`|'') +% instead of |\paren|. +% +% For example, you can use |`\Big(1+\hat{f}`\big(x))| or +% |\paren\Big(1+\hat{f}\paren\big(x))| instead of +% |\Bigl(1+\hat{f}\bigl(x\bigr)\Bigr)|, to display +% $`\Big(1+\hat{f}`\big(x))$. In this way, the writing is more condensed. +% Moreover, you don't have to repeat the size for the second delimiter, +% making it easier to change the delimiter sizes if you later change your +% mind. See further examples in \autoref{sec:examples}. +% +% \iffalse META-COMMENT :: TOO LONG +% \begin{verbatim} +% \begin{align} +% P\,`\bigg[\Phi_{XA\to X'A}`*(\sigma_{XR}\otimes +% \frac{P_A\Gamma_A P_A}{\tr P_A\Gamma_A}) +% \,,\; \rho_{X'R}\otimes +% \frac{P'_{A'}\Gamma_{A'}P'_{A'}}{\tr P'_{A'}\Gamma_{A'}} +% ] \leqslant \epsilon\ . +% \end{align} +% \end{verbatim} +% for: +% \begin{align} +% P\,`\bigg[\Phi_{XA\to X'A}`*(\sigma_{XR}\otimes +% \frac{P_A\Gamma_A P_A}{\tr P_A\Gamma_A}) +% \,,\; \rho_{X'R}\otimes +% \frac{P'_{A'}\Gamma_{A'}P'_{A'}}{\tr P'_{A'}\Gamma_{A'}} +% ] \leqslant \epsilon\ . +% \end{align} +% \fi +% +% +% \section{The \phfverbpren{} command and \phfverb` backtick shorthand} +% +% \DescribeMacro{\paren} The basic macro of this package is |\paren|. It +% handles a parenthetic expression including parsing matching delimiters +% and adjusting their sizing. +% +% \leavevmode\marginpar{\raggedleft\phfverb`\texttt\ldots} The backtick +% char provides a shorthand for specifying |\paren|. It is useful to +% de-clutter long formulas. +% +% The syntax for |\paren| and |`| is: +% \begin{center} +% |\paren|\meta{optional size argument}\meta{open-delimiter} \ldots \meta{close-delimiter} +% \par or\par +% |`|\meta{optional size argument}\meta{open-delimiter} \ldots \meta{close-delimiter} +% \end{center} +% +% By default, the following pairs of delimiters are recognized: +% |\paren(expression in parenthesis)|,\\ +% |\paren[expression in brackets]|,\\ +% |\paren|,\\ +% |\paren\{expression in curly braces\}|, and\\ +% |\paren{expression in curly braces}| (alternative syntax for curly +% braces). Of course, the same are available with the backtick shorthand: +% |`(expression)|, |`[expression]|, |`|, and so on. +% +% Delimiters are balanced, meaning that % +% |\paren[g[x] + f[x]]| is parsed as you would expect (the expression is % +% ``|g[x] + f[x]|'') and not as \TeX/\LaTeX{} usually parses default +% arguments (in which case the argument would be ``|g[x|''). \iffalse]\fi +% +% +% The optional size argument must be a single token. It may be one of |*|, +% |\big|, |\Big|, |\bigg|, |\Bigg|, or another standard sizing command. If +% the optional size argument is |*|, then the delimiters are sized with +% |\left(| \ldots{} |\right)|, that is, they are sized +% automatically. +% +% \subsection{Examples} +% \label{sec:examples} +% +% \makeatletter +% \def\showcaseexample{\begingroup\catcode`\\=12\catcode`\_=12\catcode`\^=12\catcode`\{=12\catcode`\}=12\relax\showcaseexample@} +% \def\showcaseexample@!!#1!!{\endgroup\showcaseexample@@{#1}{\scantokens{#1}}} +% \def\showcaseexample@@#1#2{\par\noindent\begin{minipage}{0.5\textwidth}\centering\ttfamily #1\end{minipage}\hspace{0.05\textwidth}\begin{minipage}{0.45\textwidth}\centering $\displaystyle #2$\end{minipage}\par\vskip 0.5em\relax} +% \makeatother +% +% \showcaseexample!! \log\paren\big( a + \sin(x) - y) !! +% \showcaseexample!! \log`\Big( a + \sin(x) - y) !! +% \showcaseexample!! \log`*( \sum_k`\big[ a_k^\dagger - a_k ] ) !! +% \showcaseexample!! F = `\big< f(x) >_x = `*< \sum g(`

) > !! +% \showcaseexample!! `\Big[\sum_j `[x]^2 - \sum [y]^2 + \sum f`*(x_3^\dagger)^2] !! +% \showcaseexample!! `(z + \backtick x) !! +% \showcaseexample!! `\{\vec z\} !! +% \showcaseexample!! `{\vec z} !! +% \showcaseexample!! `*{ \vec z : \sum_i z_i = 1 } !! +% \showcaseexample!! `\big{ \vec z : \sum_i z_i = 1 } !! +% +% +% +% \subsection{Controlling the behavior of the \phfverb` backtick shorthand} +% +% The behavior of the backtick character is only altered in math mode. The +% character works as normal in text mode. (Its catcode is in fact not +% changed, only its mathcode.) +% +% \DescribeMacro{\backtick} If you need a literal backtick, you may in any +% case use the macro |\backtick|. +% +% You may use the |backtick| package option to enable or disable the |`| +% backtick shorthand. +% +% \begin{pkgoptions} +% \item[backtick=true] Enable the |`| backtick shorthand. This is the +% default. +% \item[backtick=false] Disable the |`| backtick shorthand. A backtick +% character in math mode will now simply display a backtick character. +% \end{pkgoptions} +% +% \DescribeMacro{\parenMakeBacktickActiveParen} You may use the command +% |\parenMakeBacktickActiveParen| to enable the backtick shorthand at any +% time in the document. Similarly, the command +% \DescribeMacro{\parenMakeNormalBacktick} |\parenMakeNormalBacktick| +% disables the backtick shorthand. These changes are local to \LaTeX{} +% groups, which means that you can temporarily disable the backtick +% shorthand with +% \begin{verbatim} +% {\parenMakeNormalBacktick Normal backtick in math mode: $`$.} +% \end{verbatim} +% +% +% \section{Declaring matching delimiters and corresponding representations} +% +% \DescribeMacro{\parenRegister} Register a new delimiter type with +% |\parenRegister|. This macro should only be called in the preamble. +% +% Syntax is: |\parenRegister|\marg{internal name}\marg{open parse +% delimiter}\marg{close parse delimiter}\marg{open display +% delimiter}\marg{close display delimiter}. +% +% The \meta{internal name} is just an internal identifier: use plain ascii +% chars please (e.g. ``|angbrackets|''). +% +% The \meta{open parse delimiter} and \meta{close parse delimiter} are +% those characters which will be used to parse the delimited expression. +% They may differ from the actual delimiters used to display the +% expression, given by \marg{open display delimiter} and \marg{close +% display delimiter}. +% +% For example, you may use +% \begin{verbatim} +% \parenRegister{angbrackets}{<}{>}{\langle}{\rangle} +% \end{verbatim} +% to instruct |\paren| (and |`|) to do the following: whenever the ``|<|'' +% open delimiter is encountered, then the expression is to be parsed within +% the delimiters % +% ``|< ... >|,'' and the final expression is to be delimited as % +% ``|\langle ... \rangle|,'' where the |\langle| and |\rangle| are possibly +% sized according to an optional size argument. +% +% You may repeat calls to |\parenRegister|, with different internal +% identifiers, to register different kinds of delimiters. It is always the +% opening delimiter which determines which registered info to use. +% +% \begin{pkgnote} +% With older versions of \pkgname{xparse} (older than +% \texttt{2015/11/04}), only single-character tokens or single-character +% escape sequences (such as |\{|) could be used as delimiters for parsing +% (second and third arguments to |\parenRegister|). +% +% Otherwise, with versions of \pkgname{xparse} newer than +% \texttt{2015/11/04}, you may use full macros to delimit content, for +% example |\parenRegister{testang}{\start}{\stop}{\langle}{\rangle}| +% allows you to write e.g.\@ \fbox{\phfverb{`\start content...\stop}}, +% and the content will be displayed in angle brackets. +% \end{pkgnote} +% +% \DescribeMacro{\parenRegsiterSimpleBraces} The case where the delimiters +% are a normal \LaTeX{} group, that is ``|`{...}|,'' is treated specially. +% In this case, you need to specify which internal identifier to fall back +% to. For example, if you defined +% |\parenRegister{braces}{\{}{\}}{\{}{\}}|, then you may use +% |\parenRegisterSimpleBraces{braces}| to instruct |\paren| (and |`|) to +% use curly braces whenever both the forms |`\{...\}| and |`{...}| are +% used. +% +% \DescribeMacro{\parenRegisterDefaults} Register the default set of +% delimiters: |`(...)|, |`[...]|, |`<...>|, |`\{...\}|, and with |`{...}| +% the same as |`\{...\}|. +% +% There is a package option |registerdefaults| to instruct to load or not +% to load the default set of delimiters: +% \begin{pkgoptions} +% \item[registerdefaults=true] Set up the default set of delimiters +% provided by |\parenRegisterDefaults| when loading the package. This is +% the default. +% \item[registerdefaults=false] Do not set up any delimiters. It is your +% job to call |\parenRegister| as necessary to register all your +% delimiters. +% \end{pkgoptions} +% +% +% +% +% +% +% +% +% +% +% +% +% +% +% +% \StopEventually{\PrintChangesAndIndex} +% +% \section{Implementation} +% +% Load some utility packages. +% +% \begin{macrocode} +\RequirePackage{etoolbox} +\RequirePackage{kvoptions} +\RequirePackage{xparse} +\RequirePackage{amsmath} +\RequirePackage{mathtools} +% \end{macrocode} +% +% +% \subsection{Internal \phfverbpren{} API for different delimiters} +% \label{sec:internal-API-for-delimiters} +% +% The idea is to combine the power of the delimiter-parsing mechanism of +% \pkgname{xparse} with the display power of paired delimiters provided by +% \pkgname{mathtools}. With \pkgname{xparse}, you can define commands +% which parse an argument given by arbitrary (but fixed) delimiters. The +% \pkgname{mathtools} package allows you to define commands such as |\abs| +% with |\DeclarePairedDelimiter|, such that you can use them as |\abs{x}| +% for default delimiter sizes, |\abs*{x}| for automatic delimiter sizing, +% and |\abs[\big]{x}| to use an explicitly given size. +% +% The idea for |\paren| is the following: detect what the open delimiter +% is, and relay the call to a macro which knows how to parse a balanced +% argument with those delimiters. That macro then relays the call to the +% paired-delimiter-display macro with appropriate star, optional argument +% and mandatory argument. +% +% When parsing, a delimiter set is recognized by its opening delimiter +% token. Furthermore, to each delimiter set corresponds an internal +% identifier name. +% +% A delimiter set is declared by |\parenRegister| via three macros. First, +% the macro |\paren@registered@delims@|\meta{open delimiter token (as +% \phfverb\string)} is defined to expand to the internal identifier name +% for this delimiter pair. +% +% Then, the macro |\paren@impl@|\meta{internal identifier name} is defined +% to accept one argument, the possible modifiers passed to |\paren| before +% the opening delimiter. +% +% Finally, the macro |\paren@impl@|\meta{internal identifier name}|@go| is +% a |\DeclarePairedDelimiter|-declared macro which can display the +% delimited expression. +% +% +% \subsection{Implementation of \phfverbpren} +% +% \begin{macro}{\paren} +% Define the main |\paren| macro. The syntax is: +% |\paren|\meta{modifier-token}\meta{delimited-argument}, where +% modifier-token is optional and can be |*| or a sizing command such as +% |\big|. +% +% Because of the way \LaTeX{} parses arguments, we need to treat the case +% |\paren{...}| separately form, say, |\paren\{...\}|. Recall that +% |\@ifnextchar\bgroup| checks for an opening brace. Then, delegate call +% to appropriate macro for further processing. +% \begin{macrocode} +\def\paren{% + \@ifnextchar\bgroup\paren@impl@bgroup\paren@impl@nobgroup% +} +% \end{macrocode} +% +% Treat the special case in which we have a single \LaTeX{} group as +% argument, no modifiers. In this case, directly call the display macro +% corresponding to the delimiter set we should use in this case. (We know +% that the main argument follows in the input token chain.) +% \begin{macrocode} +\def\paren@impl@bgroup{% + \csname paren@impl@\paren@registered@default @go\endcsname% +} +% \end{macrocode} +% +% +% Parse the following token. See if |#1| is an opening delimiter. Do that +% by seeing if |#1| is a known and registered delimiter by checking if +% |\paren@registered@delims@|\meta{open delimiter token as \phfverb\string} +% is defined. If it is not a recognized open delimiter, assume that it is +% a modifier token. +% \begin{macrocode} +\def\paren@impl@nobgroup#1{% + \ifcsdef{paren@registered@delims@\string#1}{% + \paren@impl@nomod{#1}% + }{% + \paren@impl@mod{#1}% + }% +} +% \end{macrocode} +% +% We have just parsed and recognized an open delimiter token, repeated here +% as argument |#1|. So get the internal delimiter identifier via +% |\paren@registered@delims@\string|\meta{open delim}, and relay the call +% to |\paren@impl@|\meta{internal delim identifier}. Don't forget an empty +% argument as we saw no modifier tokens. +% \begin{macrocode} +\def\paren@impl@nomod#1{% + \letcs\paren@tmp@delimname{paren@registered@delims@\string#1}% + \csname paren@impl@\paren@tmp@delimname\endcsname{}#1% + % +} +% \end{macrocode} +% +% We have just seen a token which is not recognized as an open delimiter, +% so we've assumed it's a modifier token (repeated here as |#1|). Store it +% in |\paren@tmp@modtoken|, and parse further, keeping in mind that again +% we may have a \LaTeX{} braced group instead of a single token. +% \begin{macrocode} +\def\paren@impl@mod#1{% + \def\paren@tmp@modtoken{#1}% + \@ifnextchar\bgroup\paren@impl@modBgroup\paren@impl@modNobgroup% +} +% \end{macrocode} +% +% We have seen a modifier token, then a \LaTeX{} braced group. First, use +% |\paren@util@parseModifs| to parse the modifier token and to get the +% actual argument to the |\DeclarePairedDelimiter|-defined macro. Then, +% see which delimiter set to fall back to, and relay the call to that +% including the modifier flags. +% \begin{macrocode} +\def\paren@impl@modBgroup{% + \paren@util@parseModifs\paren@tmp@modifsForMathtools\paren@tmp@modtoken% + \letcs\paren@tmp@gocmd{paren@impl@\paren@registered@default @go}% + \expandafter\paren@tmp@gocmd\paren@tmp@modifsForMathtools% +} +% \end{macrocode} +% +% We have seen a modifier token, stored in |\paren@tmp@modtoken|, and now +% there is a next token coming in (|#1|) which has to be the open delimiter +% (there cannot be several modifier tokens). First, check that the given +% delimiter is known and registered. +% |\paren@registered@delims@|\meta{delimiter token as \phfverb\string} +% should be defined to be the internal name of the registered delimiter. +% Then, call the implementation for that delimiter with the modifier-token +% as argument, and let that do the actual parsing. +% \begin{macrocode} +\def\paren@impl@modNobgroup#1{% + \ifcsdef{paren@registered@delims@\string#1}{% + \letcs\paren@tmp@delimname{paren@registered@delims@\string#1}% + \letcs\paren@tmp@delimcmd{paren@impl@\paren@tmp@delimname}% + \edef\paren@tmp@modtokenarg{{\expandonce\paren@tmp@modtoken}}% + \expandafter\paren@tmp@delimcmd\paren@tmp@modtokenarg#1% + }{% +% \end{macrocode} +% +% In the event the open delimiter is not recognized, display an error +% message, and attempt to recover by keeping all arguments as text tokens. +% \begin{macrocode} + \PackageError{phfqit}{Unknown delimiter: (or can't parse args?) + {\expandafter\string\paren@tmp@modtoken}{\string#1}}{Your call + to \string\paren couldn't be parsed, presumably because I didn't + recognize your delimiter, or because there's a bug in this + package.}% + \paren@tmp@modtoken#1% + }% +} +% \end{macrocode} +% \end{macro} +% +% +% \subsection{Some Utilities} +% +% \begin{macro}{\paren@util@parseModifs} +% Parse a modifier token, and generates the appropriate size argument +% tokens (star or optional argument) for a +% |\DeclarePairedDelimiter|-declared command. +% +% \par |#1| = new macro name to be defined. +% \par |#2| = macro containing the modifier token. (Will be expanded +% once.) +% +% A call to |\paren@util@parseModifs| defines |#1| to contain +% mathtools-compatible size args. |#2| is expanded once, so it is +% expected to be a macro which contains the relevant modifiers. +% +% \begin{macrocode} +\def\paren@util@parseModifs#1#2{% +% \end{macrocode} +% +% If the modifier token is a star |*|, then the argument should be a simple star. +% \begin{macrocode} + \expandafter\ifstrequal\expandafter{#2}{*}{% + \def#1{*}% + }% +% \end{macrocode} +% Otherwise, if there is something and |#2| is not blank, put it in an +% optional argument (square braces). +% \begin{macrocode} + {% (else:) + \expandafter\ifblank\expandafter{#2}{% + \def#1{}% + }{% + \edef#1{[\expandonce{#2}]}% + }% + }% +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\paren@xparsefix@storeparenarg} +% The second utility is a fix for a bug (or feature?) in +% \pkgname{xparse}. It seems that when specifying a delimited argument +% with |r|\meta{open}\meta{close}, if the \meta{open} delimiter is not a +% single character, then the argument is not properly prepared: for +% example, with some versions of \pkgname{xparse}, for delimiters +% |r\{\}|, we get for the macro call |\mymacro\{hi there\}| as parsed +% argument |{hi there|. This bug was not present in older versions of +% \pkgname{xparse}, where it was impossible to use full macros as +% delimiters, but it seemed to have been introduced in more recent +% versions (tracked to starting from version \texttt{2015/11/04}). +% +% So we wrap the fix into a macro +% |\paren@xparsefix@storeparenarg|\marg{main argument which may need +% fix}. This defines the macro |\paren@tmp@contents| which is the actual +% argument, possibly fixed. +% +% The caller must ensure that the macro |\paren@impl@tmp@delimtoken| is +% defined to expand to the opening delimiter token. +% +% The default implementation assumes that \pkgname{xparse} doesn't have +% the bug. +% \begin{macrocode} +\def\paren@xparsefix@storeparenarg#1{% + \def\paren@tmp@contents{#1}% +} +% \end{macrocode} +% +% Now, redefine this macro to the correct fix depending on the +% \pkgname{xparse} package version. If the version is more recent than +% \texttt{2015/11/04}, then we need to strip macro name length (excluding +% backslash char) from beginning of argument. +% \begin{macrocode} +\@ifpackagelater{xparse}{2015/11/04}{ + \RequirePackage{xstring}% + \def\paren@xparsefix@storeparenarg#1{% + \fullexpandarg\StrLen{\expandafter\string\paren@impl@tmp@delimtoken}% + [\paren@tmp@delimstrlen]% + \ifnum\paren@tmp@delimstrlen=1\relax% + \def\paren@tmp@contents{#1}% + \else% + \def\paren@tmp@delimstrlen@{\numexpr\paren@tmp@delimstrlen-1\relax}% + \noexpandarg\StrGobbleLeft{#1}{\the\paren@tmp@delimstrlen@}% + [\paren@tmp@contents]% + \fi% + }% +}{% +} +% \end{macrocode} +% \end{macro} +% +% +% \subsection{Registering Delimiters} +% +% Helper to register a delimiter set for use with |\paren|. +% +% \begin{macro}{\parenRegister} +% The macro |\parenRegister| defines the necessary macros documented in +% \autoref{sec:internal-API-for-delimiters}. Namely, +% |\paren@registered@delims@|\meta{open delimiter token, \phfverb\string +% ified} expands to the internal registered \meta{identifier} for this +% delimiter. Then, defines |\paren@impl@| which is a parser for +% this delimiter and calls the mathtools goodies +% etc. |\paren@impl@| takes one mandatory argument, which is all +% the stuff to insert before the open delimiter and to pass on to +% mathtools (just a |*| or a delimiter size), and then reads the +% delimited (balanced) content. +% +% The syntax is |\parenRegister|\marg{identifier}\marg{open delimiter +% token}\marg{close delimiter token}\marg{display open +% delimiter}\marg{display close delimiter}. +% +% This macro should only be called in the preamble. +% \begin{macrocode} +\newcommand\parenRegister[5]{% +% \end{macrocode} +% \iffalse meta-comment %}{ -- for matching braces in my editor +% \fi +% +% First, define the actual |\DeclarePairedDelimiter|-type command +% |\paren@impl@#1@go| which displays the final delimited expression. +% Recall that |#1| = the internal identifier, while |#4| and |#5| are the +% delimiters we should use to display the expression. +% +% Use |\DeclarePairedDelimiterX| so that we put the main argument inside a +% \LaTeX{} group, just to be sure. (For example, we want to make sure that +% in arguments such as |-1|, the minus sign is a unary minus and not seen +% as a binary operator.) +% \begin{macrocode} + \expandafter\DeclarePairedDelimiterX\csname paren@impl@#1@go\endcsname[1]{#4}{#5}{{##1}} +% \end{macrocode} +% +% The second macro is the one which is capable of parsing the balanced, +% delimited expression, while first taking a mandatory argument containing +% the possible modifier token. +% +% Here, we just read the modifier token and store them in a temporary +% macro, while relaying the delimiter parsing to a helper macro (not sure +% why this is necessary). +% \begin{macrocode} + \csdef{paren@impl@#1}##1{% + \gdef\paren@impl@tmp@modifs{##1}% + \csname paren@impl@#1@parsedelim\endcsname% + } + \expandafter\DeclareDocumentCommand\csname paren@impl@#1@parsedelim\endcsname{r#2#3}{% + \letcs\paren@impl@tmp@gocmd{paren@impl@#1@go}% +%%\message{********MESSAGE*********}% +%%\message{**********\detokenize\expandafter{\paren@impl@tmp@modifs}**********}% +%%\message{**********\detokenize{##1}***********}% + \paren@util@parseModifs\paren@impl@tmp@modifsForMathtools\paren@impl@tmp@modifs% +%%\show\paren@impl@tmp@modifsForMathtools% + \def\paren@impl@tmp@delimtoken{#2}% + \paren@xparsefix@storeparenarg{##1}% +%%\show\paren@impl@tmp@modifsForMathtools +%%\show\paren@tmp@contents + \expandafter\paren@impl@tmp@gocmd\paren@impl@tmp@modifsForMathtools{\paren@tmp@contents}% +} +% \end{macrocode} +% +% Finally, register this open delimiter to be detected by the |\paren| +% macro. With this, |\paren| also knows the internal identifier associated +% to this open delimiter token. +% \begin{macrocode} + \csdef{paren@registered@delims@\string#2}{#1} +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\parenRegisterSimpleBraces} +% Specify the internal name for the delimiter which should be used in the +% syntax |`{...}| or |\paren{...}| (with or without modifier token). +% +% If this macro is called multiple times, the last specified name is +% used. +% \begin{macrocode} +\newcommand\parenRegisterSimpleBraces[1]{% + \def\paren@registered@default{#1}% +} +% \end{macrocode} +% \end{macro} +% +% +% \begin{macro}{\parenRegisterDefaults} +% A macro which registers the default set of delimiters. +% \begin{macrocode} +\newcommand\parenRegisterDefaults{ +% \end{macrocode} +% \iffalse meta-comment %}{ -- for matching braces in my editor +% \fi +% +% The default set of delimiters: +% \begin{macrocode} + \parenRegister{parens}{(}{)}{(}{)} + \parenRegister{brackets}{[}{]}{[}{]} + \parenRegister{angbrackets}{<}{>}{\langle}{\rangle} + \parenRegister{braces}{\{}{\}}{\{}{\}} +% \end{macrocode} +% +% And the registered paren type to use when given the syntax |`{...}|: +% curly braces. +% \begin{macrocode} + \parenRegisterSimpleBraces{braces} +} +% \end{macrocode} +% \end{macro} +% +% +% \subsection{Handle backtick shorthand} +% +% \begin{macro}{\parenMakeBacktickActiveParen} +% Change the behavior of the backtick character in math mode to +% (|\parenMakeBacktickActiveParen|) be an alias for |\paren|. +% \begin{macrocode} +\def\parenMakeBacktickActiveParen{% +% \end{macrocode} +% +% Set the backtick character to be active, but only in math mode. It still +% has its normal |\catcode|, only its |\mathcode| is altered. +% \begin{macrocode} +\mathcode`\`="8000\relax% +% \end{macrocode} +% +% Use the usual |\lccode|-trick to do ``|\def`{...}|'' but for an active |`| char +% \begin{macrocode} + \begingroup% + \lccode`\~=`\`% + \lowercase{\endgroup\def~}{\paren}% +} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\parenMakeNormalBacktick} +% The command |\parenMakeNormalBacktick| changes the behavior of the +% backtick character in math mode to be a normal backtick char +% (``$\backtick$''). +% \begin{macrocode} +\def\parenMakeNormalBacktick{\mathcode`\`="0060\relax} +% \end{macrocode} +% \end{macro} +% +% \begin{macro}{\backtick} +% A literal backtick. Simply done by temporarily disabling our backtick +% shorthand within a \LaTeX{} group. +% \begin{macrocode} +\def\backtick{\begingroup\parenMakeNormalBacktick`\endgroup} +% \end{macrocode} +% \end{macro} +% +% +% +% +% \subsection{Parse package options} +% +% +% Set up \pkgname{kvoptions} option parsing. +% \begin{macrocode} +\SetupKeyvalOptions{ + family=phfparen, + prefix=phfparen@opt@ +} +% \end{macrocode} +% +% +% Option \pkgoptionfmt{backtick}, and complementary option \pkgoptionfmt{nobacktick}. +% \begin{macrocode} +\DeclareBoolOption[true]{backtick} +\DeclareComplementaryOption{nobacktick}{backtick} +% \end{macrocode} +% +% For backwards compatibility with my previous versions of +% \pkgname{phfparen}: provide the |backtickon| package option. +% \begin{macrocode} +\DeclareVoidOption{backtickon}{% + \phfparen@opt@backticktrue + \PackageWarning{phfparen}{Option 'backtickon' is deprecated. It still works, + but please consider using 'backtick=true|false' instead.}% +} +% \end{macrocode} +% +% +% +% Option \pkgoptionfmt{registerdefaults} to specify whether to register the +% default set of delimiters or not. +% \begin{macrocode} +\DeclareBoolOption[true]{registerdefaults} +\DeclareComplementaryOption{noregisterdefaults}{registerdefaults} +% \end{macrocode} +% +% +% Finally, process the options. +% \begin{macrocode} +\DeclareDefaultOption{% + \@unknownoptionerror +} +\ProcessKeyvalOptions* +% \end{macrocode} +% +% +% Now, execute the settings dictated by the user options. +% \begin{macrocode} +\ifphfparen@opt@backtick + \parenMakeBacktickActiveParen +\fi +\ifphfparen@opt@registerdefaults + \parenRegisterDefaults +\fi +% \end{macrocode} +% +%\Finale +\endinput diff --git a/Master/texmf-dist/source/latex/phfparen/phfparen.ins b/Master/texmf-dist/source/latex/phfparen/phfparen.ins new file mode 100644 index 00000000000..2462474b482 --- /dev/null +++ b/Master/texmf-dist/source/latex/phfparen/phfparen.ins @@ -0,0 +1,55 @@ +%% +%% Copyright (C) 2016 by Philippe Faist +%% +%% This file may be distributed and/or modified under the conditions of +%% the LaTeX Project Public License, either version 1.3 of this license +%% or (at your option) any later version. The latest version of this +%% license is in: +%% +%% http://www.latex-project.org/lppl.txt +%% +%% and version 1.3 or later is part of all distributions of LaTeX version +%% 2005/12/01 or later. +%% + +\input docstrip.tex +\keepsilent + +\usedir{tex/latex/phfqitltx} + +\preamble + +This is a generated file. + +Copyright (C) 2016 by Philippe Faist + +This file may be distributed and/or modified under the conditions of +the LaTeX Project Public License, either version 1.3 of this license +or (at your option) any later version. The latest version of this +license is in: + + http://www.latex-project.org/lppl.txt + +and version 1.3 or later is part of all distributions of LaTeX version +2005/12/01 or later. + +\endpreamble + +\generate{\file{phfparen.sty}{\from{phfparen.dtx}{package}}} + +\obeyspaces +\Msg{*************************************************************} +\Msg{* *} +\Msg{* To finish the installation you have to move the following *} +\Msg{* file into a directory searched by TeX: *} +\Msg{* *} +\Msg{* phfparen.sty *} +\Msg{* *} +\Msg{* To produce the documentation run the .dtx file through *} +\Msg{* (PdF-)LaTeX. *} +\Msg{* *} +\Msg{* Happy TeXing! *} +\Msg{* *} +\Msg{*************************************************************} + +\endbatchfile -- cgit v1.2.3