summaryrefslogtreecommitdiff
path: root/macros/amstex/doc/amstex.txt
diff options
context:
space:
mode:
Diffstat (limited to 'macros/amstex/doc/amstex.txt')
-rw-r--r--macros/amstex/doc/amstex.txt3468
1 files changed, 3468 insertions, 0 deletions
diff --git a/macros/amstex/doc/amstex.txt b/macros/amstex/doc/amstex.txt
new file mode 100644
index 0000000000..243b77ee3a
--- /dev/null
+++ b/macros/amstex/doc/amstex.txt
@@ -0,0 +1,3468 @@
+AMSTEX.DOC (FOR AMSTEX.TEX VERSION 2.0)
+COPYRIGHT (C) 1989 BY MICHAEL SPIVAK
+
+THIS COPYRIGHTED MATERIAL MAY BE REPRODUCED, EITHER IN PRINTED FORM,
+OR AS A COMPUTER FILE, WHICH MAY THEN BE PLACED ON ANY COMPUTER OR
+COMPUTER NETWORK, PROVIDED THAT THE FIRST TWO LINES OF THIS FILE, AS
+WELL AS THIS PARAGRAPH, ARE ALSO REPRODUCED. IT MAY NOT BE SOLD,
+EXCEPT FOR A NOMINAL FEE NOT TO EXCEED $5.00 PER COPY; CHARGES FOR
+SHIPPING MAY BE ADDED, BUT ADDITIONAL CHARGES FOR PACKAGING,
+HANDLING, ETC., ARE EXPRESSLY FORBIDDEN.
+
+
+This is the documentation for AmS-TeX, specifically the file
+AMSTEX.TEX.
+
+
+**********************************************************************
+Comments of the form %1, %2, etc., accompany the %1, etc., that occur
+within the file AMSTEX.TEX in the definition of the construction in
+question.
+**********************************************************************
+
+
+**********************************************************************
+Some explanations given earlier in the file will be required at later
+points. Such material is often set off by lines of *'s, like this.
+TB refers to The TeXbook.
+**********************************************************************
+
+
+\def\fmtname ...
+----------------
+We record the format name in \fmtname, overriding the definition that
+comes from plain. But we store the format version for plain in
+\plainfmtversion, in case someone needs to look at that, and record
+the version of AmS-TeX in \fmtversion.
+
+
+**********************************************************************
+\catcode`\@=11
+--------------
+We make @ a letter, so that we can make private control sequences,
+which we won't have to worry about users wanting to define
+themselves. The private control sequences from plain, like \p@,
+\@ne, etc., are also used extensively. Most of the time optional =
+signs are omitted. (Note, however, that in a test like \ifnum< >=< >
+the = is NOT optional.)
+**********************************************************************
+
+
+\ifx\amstexloaded@
+------------------
+We have to prevent AMSTEX.TEX from being read in twice; see TB,
+p. 382 (and the definition of \/). The code didn't fit on one line;
+it was imperative that the \endinput...\fi was all on one line,
+however.
+
+
+\W@, \CR@
+---------
+\W@ writes to screen and log file.
+
+\CR@, the copyright notice, is defined as a sequence of \W@'s. We
+use \fmtversion so that the first line doesn't have to be changed.
+
+
+\CR@
+----
+Then we print the copyright notice.
+
+
+\everyjob{\CR@}
+---------------
+Then we make sure it's printed even if a format file is made.
+
+
+**********************************************************************
+\toksdef\toks@@
+---------------
+We will need a second scratch token, in addition to \toks@ (TB,
+p. 346); \toks@@ is set to \toks2, rather than \toks1, in accordance
+with rule (3) on that page.
+**********************************************************************
+
+
+\rightappend@ is \rightappend from TB, p. 378.
+
+
+\def\alloclist@
+----------------
+We modify the allocation routines from TB, Appendix B, so that
+nothing is written to the log file. But we collect all information
+that might go there, so that it can be written later if
+\showallocations appears in the input file. \alloclist@ will be the
+list of things that previously went to the log file, in the form of
+TB, p. 378.
+
+
+\showallocations writes each thing in \alloclist@, and sets a flag
+\ifalloc@ for any later things to be written.
+
+
+\alloc@ is redefined from TB, p. 347. Near the end, it will be redefined
+once again. We \edef\next@ to be the token list that we want added to
+\alloclist@ by \rightappend@, so that \the\allocationnumber will be
+expanded out to the actual number.
+
+
+**********************************************************************
+We will be using the scratch tokens \next, \next@, \nextii@,
+\nextiii@, etc. In order to keep the number down, many definitions
+will, for example, define \nextiv@ back in terms of \next@, \nextii@,
+etc. There is only one problem that we have to guard against:
+Sometimes our definitions have clauses like \def\next@{ ... \next
+...}. The definitions of \next@ won't be made until these
+definitions are invoked, and at that time \next might be \outer (!!)
+because some previous \futurelet may have \let\next be something that
+is \outer; this error will only be encountered at that time, not when
+the definitions are read by AmS-TeX, because \next isn't outer when
+AmS-TeX is making the definition! So we could end up with a pretty
+incomprehensible error message at some point when AmS-TeX is being
+used. Similarly, an outer \next might cause a problem if it is used
+in some \if... construction, since outer control sequences aren't
+allowed while TeX is skipping conditional text. To guard against
+this, we will, first of all, always reserve \next for \futurelet
+constructions. That is why \next@ is used instead of \next in our
+redefinition of \alloc@. Later we will mention the other thing we
+have to do to guard against the problem.
+**********************************************************************
+
+
+\newcount\count@@, \newcount\count@@@
+-------------------------------------
+We will need two more counters. Since \count@, \count@@, and
+\count@@@ will all be used only for local assignments, we don't
+bother with rule (3) of TB, p. 346.
+
+
+\FN@, \DN@, \DNii@, \RIfM@, \RIfMIfI@, \setboxz@h, \wdz@,
+ \boxz@, \setbox@ne, \wd@ne
+---------------------------------------------------------
+These definitions abbreviate combinations that occur sufficiently
+often to make it worthwhile using up control sequence names.
+
+
+\iterate, from plain, is redefined using the method of Kabelschacht,
+see TUGboat, Volume 8, No. 2, p. 184.
+
+
+**********************************************************************
+It is assumed that the user of this documentation already understands
+why it is often necessary to use constructions like
+
+ \if...\def\next{\csa}\else\def\next{\csb}\fi\next
+
+instead of simply \if...\csa\else\csb\fi.
+
+Kabelschacht's method also replaces this by the construction
+
+ \if...\expandafter\csa\else\expandafter\csb\fi.
+
+We will call this the ``K-method''. The K-method will often be used
+without explicit mention; however, it is not always valid or
+practicable, as we will mention later.
+**********************************************************************
+
+
+^^J is made the \newlinechar for help messages, and also for use in
+the definition of \comment later on.
+
+
+\err@ is the standard form for AmS-TeX error messages.
+
+
+\newhelp\defaulthelp@
+---------------------
+We make a standard default help, equivalent to the usual second level
+help message you get with TeX (so that there won't be an error
+message from TeX saying that it doesn't know how to give help).
+
+
+\Err@ is the standard form for AmS-TeX error messages with default
+help.
+
+
+\eat@ is used to gobble tokens.
+
+
+\in@ tests whether string #2 contains token #1; see TB, p. 379,
+setting a flag \ifin@.
+
+
+**********************************************************************
+\def\space@
+-----------
+We frequently need a token that is \let equal a space. The % after
+`\space@. ' insures that the space isn't deleted.
+**********************************************************************
+
+
+\athelp@
+--------
+Now comes the mechanism by which @<token> will be defined, when @ is
+made active, at the end. \athelp@ is a help message.
+
+
+{\catcode`\@=\active
+--------------------
+Now we have to define how @ will work when it will be active. This
+whole mechanism occurs within a group in which @ is active, so most
+\defs are \gdefs.
+
+
+\lccode`\Z=`\@, \lccode`\I=`\I
+------------------------------
+We want any auxiliary control sequences that are mentioned in this
+process to have the letter @ as part of their name, even though
+@ is now active, so we have to use the \lowercase trick: we set
+the \lccode of Z to be @, name such control sequences as
+\csname...Z\endcsname, and then \lowercase the whole thing. This
+often requires \expandafter. For example, we have to say
+
+ \expandafter\gdef\csname ...\endcsname,
+not
+ \gdef\csname...\endcsname.
+
+Finally, we also set the \lccode of I to I, since I appears in some
+error messages that we will be defining in this process, and we don't
+want this I changed to lowercase!
+
+Things are so complicated here, that we won't even contemplate using
+the K-method!
+
+%1 The very first thing we want to do is make @ mean
+ \futurelet\next\at@ (and then we will define \at@ in terms of
+ \next). Trying to say all that with \csname seems a hopeless
+ muddle, so we first create \futureletnextat@ to stand for that.
+
+%2 \at@ will call \at@@ if the next token is a letter or number, but
+ \at@@@ if it is a control sequence (we allow @\Vert, for example)
+ and \at@@@@, which will be an error message, otherwise.
+
+%3 \at@@ <token> will be the control sequence `\<token>@at' (created
+ by \atdef@) if this control sequence has actually been created,
+ otherwise an error message with the \athelp@ help message.
+
+%4 \at@@@\cs will be the control sequence `\\cs@@at' (created by
+ \atdef@@) or an error message.
+
+%5 \at@@@@ is an error message, which also swallows up the next
+ input.
+
+%6 The last right brace in this line matches the left brace in
+ `{\catcode`\@=\active'. The previous right brace closes the
+ `\lowercase{'.
+
+
+\atdef@<token> creates the control sequence `\<token>@at'; we don't
+test for whether this already exists, since \atdef@ isn't for the
+user.
+
+
+\atdef@@\cs creates the control sequence `\\cs@@at'. \atdef@@ can
+also be used with active characters.
+
+
+\newhelp\defahelp@, \newhelpf\defbhelp@
+---------------------------------------
+Next comes the mechanism for \define. \defahelp@ is the help message
+when the wrong syntax is used; \defbhelp@ is the help message when an
+already defined control sequence appears after the \define.
+
+
+\define gives an error message if it isn't followed by a control
+sequence, and we add the tokens \def\nextii@@ so that what follows
+gets swallowed up into the definition of \nextii@. We are using the
+K-method here, hence \expandafter\define@@ in line %1 and
+\expandafter\def\expandafter\nextii@ in line %2. Note that this
+method clearly becomes impractical when many tokens are present in
+one of the cases.
+
+
+\def\undefined@@@@@@@@@@, \def\preloaded@@@@@@@@@@, \def\next@@@@@@@@@@
+-----------------------------------------------------------------------
+We want \define@@#1 to detect whether #1 has already been \def'd.
+The idea is to use \csname\expandafter\eat@\string#1\endcsname to
+reproduce #1; since \csname...\endcsname is given the value \relax if
+it produces an undefined control sequence, using an \ifx test between
+\relax and this new control sequence tells us whether it already
+exists. But that won't work for \relax, nor for the control
+sequences \undefined and \preloaded, which we want to remain
+undefined. Moreover, we don't want the user to be able to
+\define\next, since this scratch token is often redefined by various
+macros. So first we test for \relax, and then for \undefined,
+\preloaded, or \next. For the latter, we first define
+\undefined@@@@@@@@@@, \preloaded@@@@@@@@@@, and \next@@@@@@@@@@ as {};
+these are the only control sequences with 10 @'s (in fact, there are
+none with even 5 @'s, but we might as well be on the safe side). Then
+we use \csname to construct a new control sequence `#1@@@@@@@@@@' and
+test this with \ifx against \preloaded@@@@@@@@@@; we will get true
+only for \preloaded, \undefined, and \next.
+
+One of the nice features of all this is that a control sequence \cs
+becomes undefined, and thus available to be \define'd, simply by saying
+\let\cs\undefined.
+
+There is one additional subtle point. The final test recreates #1 with
+\csname...\endcsname, and causes \def#1 to be invoked if this is \relax.
+But when \csname...\endcsname creates a new control sequence and gives it
+the value \relax, it does this GLOBALLY; more precisely, it makes it equal
+to an internal control sequence that always has the value of \relax, see
+TeX, The Program, pp. 156 and 93. If \define is being used within a group,
+we want #1 to be undefined once this group is over, so we add
+\global\let#1\undefined before we invoke the \def#1.
+
+We don't use the K-method here, since things are already so complicated.
+
+%1 Give error message if #1 is relax.
+%2 Give error message if #1 is \undefined, \preloaded, or \next.
+%3 Do \def#1 if #1 is previously undefined, otherwise give error message.
+
+
+\redefine, \predefine, should be obvious. Note that
+\predefine\cs{...} works, since the braces get removed by TeX.
+
+
+\undefine was added recently. It seems even better than \redefine: to
+redefine an already defined control sequence \cs, you just have to
+say \undefine\cs to first make it undefined.
+
+
+\captionwidth@ is used to store the default width for captions.
+It is made 1.5 inches less than \hsize. If a style file resets
+\hsize, it should use \pagewidth, to automatically reset
+\captionwidth@.
+
+
+\pagewidth,...,\vcorrection
+---------------------------
+\pagewidth resets \captionwidth@ automatically. \relax added for safety.
+
+
+\tie is a synonym for ~ but is defined slightly differently, because
+spaces are automatically ignored after \tie, but not after ~ , which
+is defined a little later on.
+
+
+\graveaccent, ..., \underscore are substitute names for some control
+symbols.
+
+\B, \D are AmS-TeX substitutes for \= and \. (\. will be redefined
+later and \= will later be made undefined).
+
+
+\let\ic@\/, \def\/
+------------------
+We want \/ to ignore spaces before it. It is this definition that
+makes it necessary to prevent AMSTEX.TEX from being read in twice.
+
+
+\textfonti, and later \textfontii, are introduced not for purposes of
+abbreviation, but because their values will sometimes be reset by
+\text.
+
+
+\t is redefined using \textfonti. It is also made a control sequence
+with two arguments for consistency (now a space is allowed before the
+second letter).
+
+
+~ differs from in plain; spaces are allowed on either side.
+
+
+\. gives a non-end-of-sentence period by specifically setting
+\spacefactor.
+
+
+\atdef@ is used to make @; and @: and @? have desired values. (But @, and
+@! are defined later, since they differ in math mode.) Just in case
+these are ever used at the beginning of a paragraph (unlikely, of
+course!), we put \leavevmode at the beginning.
+
+If some macro package makes ! active [for French punctuation,
+say], then \atdef@@! would have to be used instead of \atdef@!.
+
+
+\@ is defined directly as \char64 , since we will have @ active at
+the end (64 takes fewer tokens than '100).
+
+
+**********************************************************************
+\def\relaxnext@
+---------------
+The construction \let\next\relax, abbreviated \relaxnext@, is needed
+whenever we have a definition, like the ones to follow, where we have
+a \futurelet\next, or \ifx\next, or anything else involving \next,
+within a \def that is itself within a \def. As discussed before,
+this could lead to havoc if \next happened to be \outer, so we add
+\relaxnext@ at the beginning to protect ourselves.
+**********************************************************************
+
+
+\atdef@-
+--------
+We want @-, @-- and @--- to create \hbox{-} or \hbox{--} or
+\hbox{---}, respectively, using as many \futurelet's as needed to
+find out how many -'s there are (TeX won't hyphenate around boxes).
+
+**********************************************************************
+It would be more transparent to write the succeeding definitions as:
+
+\atdef@-{\leavevmode\futurelet\next\hyphen@}
+\def\hyphen@{\relaxnext@\ifx\next-\def\next@-{\futurelet\next
+ \hyphen@@}%
+ \else\def\next@{\leavevmode\hbox{-}}\fi\next@}
+\def\hyphen@@{\ifx\next-\def\next@-{\leavevmode\hbox{---}}\else
+ \def\next@{\leavevmode\hbox{--}}\fi\next@}
+
+But this uses up two new control sequences, \hyphen@ and \hyphen@@,
+and such constructions appear frequently, so we save control sequence
+names by using a `compressed format': the same names \next@,
+\nextii@, etc., are used within different constructions, and
+redefined within each construction. This makes things go a little
+slower, since \next@, etc., have to be redefined all the time, but
+seems worth it, especially since most such constructions are major
+formatting ones that introduce a lot of space anyway. Notice that
+the `first' clause \futurelet\next\next@ has to be made last, after
+all the subsidiary definitions have been made.
+
+In this situation, where the symbol - is made part of the syntax for
+one of \next@'s (to swallow up this -), the K-method would not work.
+**********************************************************************
+
+
+\srdr@ ...
+----------
+The kerns to put between single right-double right quotes, etc., are
+recorded in control sequences, so that they can easily be changed for
+different fonts.
+
+These values are used in defining @", which has to look ahead to see
+if it is followed by ' or '' or ` or `` . Also \lq or \rq might be
+used instead of ` or '. Finally, we also have to skip over any space
+that follows @".
+
+**********************************************************************
+AmS-TeX always does this by using a \futurelet to find out if the
+next token is a space (testing with \ifx\next\space@), and calling
+either `\next@. ' or `\next@.' The . after the \next@ makes the
+space `visible' to TeX.
+**********************************************************************
+
+Compressed format is used in \atdef@". The K-method would be
+hopelessly complicated.
+
+
+\flushpar doesn't confuse the user by having no effect if it doesn't
+happen to be used after a paragraph has ended.
+
+
+\textfontii has been mentioned previously, with \textfonti.
+
+
+\lbrace@, \rbrace@ are defined directly as delimiters, so that we can
+have \{ and \} work in math mode or outside it.
+
+
+\{, \} outside of math mode specify the actual font the character
+comes from (but as \textfontii, so it can be changed by \text), and
+we also let the \spacefactor work correctly with them. The \@sf
+construction is taken from TB, p. 363. The \relax after \@sf is
+needed (a digit might follow \}).
+
+
+\lbrace, \rbrace are made synonyms for the new \} and \{.
+
+
+\AmSTeX is now defined using \textfontii instead of math mode.
+
+
+\vmodeerr@, \mathmodeerr@ are two error messages that we will use
+frequently, with various arguments. For example, \vmodeerr@\linebreak
+gives an error message about not using \linebreak between paragraphs.
+
+
+\linebreak gives error messages unless in horizontal mode; we add an
+\unkern in case a \kern appeared at the end of previous text (for
+example, an \enspace at the end of a \proclaim).
+
+
+\slash differs from in plain; a space before it is ignored.
+
+
+**********************************************************************
+\saveskip@ is used to record previous space, given by \lastskip,
+before we \unskip to get rid of it (and then put it back with
+\saveskip@). We only \hskip\saveskip@ if \saveskip@ is non-zero,
+because a zero skip does change things---it allows breaks. Notice
+that \saveskip@\lastskip is an abbreviation for \saveskip@=\lastskip.
+Abbreviations of this sort are always used, and should be borne in
+mind.
+**********************************************************************
+
+
+\allowlinebreak uses \saveskip@.
+
+
+\refskip@ plays no role now; but after \Refs, in AMSPPT.STY, there
+will be reasons to have \refskip@ in \nolinebreak.
+
+
+\nolinebreak also uses \saveskip@.
+
+
+\newline allows \newline\par not to give an Underfull \hbox message,
+but it probably wasn't worth it to do this, since you can still
+manage to get the message if you do something weird enough, like
+\newline\newline\par. The \null keeps the \hfill from disappearing
+at the break. Compressed format is used. Within the definition of
+\next@, the K-method is used (for a conditional within a
+conditional). Although this works, the K-method doesn't work in
+general in the multi-case situation.
+
+
+\dmatherr@, ..., \nonmatherr@ are error messages that are used
+frequently.
+
+
+\mathbreak, ..., \allowmathbreak are for breaks in math mode, which
+have been arranged to require different commands than for breaks
+outside it. The main reason for this arrangement was that LaTeX-like
+features, like [...] to indicate desirability of a break, might
+later be implemented for breaks outside of math. But AmS-TeX
+definitely shies away from such use of brackets in math mode, since
+brackets are so frequently used as text in math mode, so one
+would want different commands (and different additional syntax to
+indicate desirability) for math breaks.
+
+
+\pagebreak means \removelastskip\break between paragraphs,
+\vadjust{\break} within paragraphs (to break after current line), and
+\postdisplaypenalty-10000 in display math (see TB, p. 189). The
+\removelastskip is needed in case there is already a \vskip, say from
+an \endproclaim.
+
+
+\nopagebreak is similar.
+
+
+\vnonvmodeerr@ is another useful error message.
+
+
+\vnonvmode@#1#2 does #1 if in vertical mode, otherwise #2, except
+that we are considered to be in vertical mode if a \par comes next.
+This is because users will naturally consider certain constructions
+to be `between' paragraphs if they stick them at the end of the
+paragraph, just as they count as between paragraphs if they go at the
+beginning. Compressed format is used in the definition.
+
+
+\newpage, ..., \bigpagebreak all use \vnonvmode@.
+
+
+\NoBlackBoxes, \BlackBoxes use capitals, to tell user they are global.
+
+
+
+**********************************************************************
+\Invalid@, \Invalid@@
+---------------------
+Many control sequences in AmS-TeX, like \caption and \captionwidth,
+don't have real meanings themselves, but are only indicators for
+other control sequences to take appropriate action. \Invalid@ is
+used to make their meaning an error message when they are encountered
+at unexpected times. This is more than a mere convenience for the
+user, however. If \caption, for example, were actually undefined,
+the \ifx test involving \caption could fail for unexpected reasons,
+including the misspelling of \caption in the input file.
+
+Although things like \Invalid@\caption take up little room in the
+input file, they would expand to a lot if the error message was
+always spelled out, so we abbreviate most of the error message with
+\Invalid@@.
+**********************************************************************
+
+
+\smallcaptionwidth@ is the caption width that will actually be used.
+(It may be smaller than \captionwidth@ if the caption is not that wide.)
+
+
+\topspace and \midspace are defined together, like \topinsert and
+\midinsert of plain, using a flag \ifmid@. The definition is made in
+terms of \ins@, which is similar to plain's \@ins.
+
+
+\captionfont@ is the font used for captions; it is inserted here so
+that style files that want a different font for captions can simply
+redefine \captionfont@, instead of redefining \ins@, which follows.
+
+
+\ins@ saves its argument as \thespace@, and looks ahead (skipping
+spaces) for \caption, with its argument saved as \thecaption@, and
+then for \captionwidth, with its argument saved as
+\smallcaptionwidth@ (initially set to \captionwidth@). An additional
+complication occurs because we have to skip over spaces after the }
+at the end of \caption{...} or \captionwidth{...}. The caption is
+set in a box, and centered within \smallcaptionwidth@ if smaller than
+this amount, otherwise reset into a paragraph of this \hsize. The
+\allowbreak is specifically introduced because we have no reason not
+to allow a break before the insert, and this \allowbreak may help TeX
+to find the best placement. [Cf. TB, p. 116: ``There is a slight
+.... processing text ahead of the current page. You may want to say
+`\goodbreak' just before \midinsert.'' The point is that \allowbreak
+in the definition is much better, because it causes TeX to see if a
+page break is feasible, so a break will definitely be taken if it has
+already processed too much for the current page.] Compressed format is
+used.
+
+
+\def\newcodes@ ...
+------------------
+Next comes the mechanism for \comment ... \endcomment. There are
+probably some unnecessary things here, left over from the old TeX,
+since we now use \futurelet, rather than a macro argument, to see
+what's coming, but it works, so why fool with it.
+
+
+Now we start on math constructions.
+
+
+\def\pr@m@s ...
+---------------
+\pr@m@s is changed from plain (TB, p. 357), because we don't want the
+'^ mechanism to work (since you can't get ^' to work similarly). We
+also surround the prime character with empty boxes to make sure there
+is no extra kerning around it---this character does kern with
+characters on the symbol font, because it is the \skewchar for its
+font and the kern contains information for the math accents (TB, pp.
+351 and 443). The whole construction is put inside another group, so
+that ^\prime will still work.
+
+
+\let\dsize ...
+--------------
+Now we set up AmS-TeX alternate names, and also allow \, and \! and
+\; to be used both in math mode and in text. There is an important
+reason for doing this, besides mere convenience: \, or \; might be
+used within a \format...\\ line for a \matrix (see below) to specify
+spacing. Although the user would naturally think that this spacing
+is in math mode, it actually isn't! We also make plain's \thinspace
+and \negthinspace the same as \, and \! respectively, for maximum
+consistency. Since plain's \> is almost never used we make it
+undefined (at the end), and provide \medspace instead. So we also
+add \negmedspace and \thickspace and \negthickspace.
+
+
+@, and @! will be 1/10 of \, and \! in math mode.
+
+
+@. is special in math mode, because it leaves a blank space where a
+horizontal arrow should go in commutative diagrams (see \CD below).
+
+
+\and, \implies, \impliedby are similar to plain's \iff; the \DOTSB
+are added so that \dots will know they are binary operators (see
+\dots, later).
+
+
+\frac, ..., \tfrac should be obvious.
+
+
+\ex@ is a dimension that is essentially 1 point, but that will change
+properly with changes of fonts. For cmr10, .2326ex is 1pt.
+
+
+\thickness is one of the syntax pieces \thickfrac looks for.
+
+
+\thickfrac, if followed by \thickness{<number>}, should make a
+fraction made with \above <number>\ex@. Otherwise, we want to use
+\above 1\ex@ (i.e., 1 point) for the thickness.
+
+
+\fracwithdelims, \thickfracwithdelims are strictly analogous.
+
+
+\binom, ..., \tbinom should be obvious.
+
+
+\: is for constructions like f:A --> B. Spacing was specified by AMS.
+The symbol before the \: could be a \mathbin or \mathrel (e.g.,
++\:R\times R\to R or <\:R\times R\to\{T,F\}), or even a \mathop
+(e.g., \sum\:2^R\to R). In all cases, it should be replaced by a
+\mathord, so far as the spacing in this formula is concerned. There
+is naturally no way that we can get back to the symbol preceding \:
+so we first put in a \mathpunct{}. The spacing between a \mathop or
+\mathrel and a \mathpunct is 0, and when a \mathbin precedes a
+\mathpunct, it is changed to a \mathord, so the spacing is again 0.
+Then, since the spacing between the \mathpunct{} and the \mathord {:}
+that we want to add is \nonscript\mskip\thinmuskip, we want to
+subtract this space before the {:}.
+
+
+\snug deletes the \mathsurround space, so that $n$\snug- won't have
+space between the n and the - even if \mathsurround is non-zero.
+
+
+\topsmash and \botsmash are needed in addition to just \smash from
+plain. We use a procedure similar to that used in plain for
+\phantom, which has the variants \hphantom and \vphantom (TB, p.
+360); we use much of the plain mechanism for \smash (TB, p. 360),
+using flags \iftop@, \ifbot@, mainly changing \finsm@sh. We also
+add \leavevmode before the \box\z@, in case this comes at the
+beginning of a paragraph.
+
+
+\def\LimitsOnSums ...
+---------------------
+Now we come to the modifications for the big operators like \sum. In
+each case we introduce a subsidiary name for the operator, and then
+the definition has this name followed by \slimits@, which will be
+equivalent to either \displaylimits or \nolimits, depending on the
+style. We also introduce \LimitsOnSums and \NoLimitsOnSums to allow
+the user to set the value of \slimits@. The default is \LimitsOnSums.
+The \DOTSB are added for the sake of \dots, as explained later.
+
+
+\def\LimitsOnInts ...
+---------------------
+\int and \oint are treated similarly, using \ilimits@, except that
+\intop and \ointop are already available from plain, to have
+\ilimits@ after them. We introduce \LimitsOnInts and \NoLimitsOnInts
+to allow the user to set the value of \ilimits@. The default is
+\NoLimitsOnInts. We also use \DOTSI, which is explained later.
+
+
+\def\intic@ ...
+---------------
+Next come multiple integrals. The main problem here is the proper
+positioning of a limit when limits are set above and below. For
+example, with \iint (double integral sign), the lower limit should be
+centered between the bottoms of the two integral signs, not centered
+in the whole region they make up. In such cases we basically need
+
+ \hskip-.5em\mathop{\hskip.5em\intop\intop}\limits
+
+---the \hskip.5em on the left of the two integral signs places the
+center of this symbol in the right place, and the \hskip-.5em
+corrects for it. (For a different font than cmex10, .5em might have
+to be changed.)
+
+A different correction is needed when we are not in \displaystyle, so
+\intic@, the proper correction, is defined as a \mathchoice. The
+negative amounts are stored in \negintic@, another \mathchoice, since
+it seems nearly impossible to get out the negatives of dimensions
+stored in a \mathchoice.
+
+We also need to move the integral signs closer together, by an amount
+stored in \intkern@, also a \mathchoice.
+
+Finally, the dots to be used in \idotsint (two integral signs
+separated by dots) are defined in \intdots@, again a \mathchoice.
+This uses \plaincdots@, defined later, which is basically \cdots as
+in plain (\cdots itself will be redefined later also).
+
+
+\newcount\intno@ ...
+--------------------
+To define all multiple integrals together, we store the number of
+integral signs in \intno@ (with \intno@ arbitrarily set to 0 for
+\idotsint), and then use \ints@ after a \futurelet construction,
+which is needed to see if \limits or \nolimits happened to have been
+typed after the control sequence.
+
+
+\def\ints@
+----------
+\ints@ first calls \findlimits@, which uses \iflimits@ to record
+whether or not limits should be used. Limits are used if the next
+token is \limits, or if \ilimits@ is set to \displaylimits and we are
+in displaystyle and the next token is not \nolimits. We also use
+\iflimtoken@ to record whether or not the next token was either
+\limits or \nolimits---we need this information, since we will have
+to \eat@ the \limits or \nolimits token if it occurs.
+
+
+\multint@ and \multintlimits@ produce the basic symbol---the proper
+number of integral signs, dots and spacing---based on \intno@.
+
+%1 If we are making \intdotsint, put in the dots.
+%2 Otherwise, put in kern before next integral sign.
+%3 If \intno@ >= 3, add second kern and int.
+%4 If \intno@ =4, add third kern and int.
+%5 Then add final int sign.
+
+\multintlimits@ uses \intop, because the result will be put inside a
+\mathop later.
+
+
+\ints@@, finally, uses \multint@ or a construction involving
+\multinlimits@ for the final result, which also depends on the value
+of \iflimtoken@.
+
+%1 If there was a \limits or \nolimits afterwards:
+%2 when we are using limits, use a special construction,
+%3 but when we're not, use the simple construction;
+%4 and then discard the \limits or \nolimits token.
+%5 Otherwise, do the same thing, but don't discard the next token.
+
+
+\def\LimitsOnNames ...
+----------------------
+We also have \nlimits@ to tell whether limits should be used on
+operator names, like \max and \min. We introduce \LimitsOnNames and
+\NoLimitsOnNames. The default is \LimitsOnNames.
+
+
+\def\nolimits@
+--------------
+Certain operator names, like \sin, should NEVER have limits, even if
+\limits has been typed afterwards, so instead of \nolimits we use
+\nolimits@, which replaces a \limits token that follows with
+\nolimits. Compressed format is used in that definition.
+
+
+\def\newmcodes@
+---------------
+When we make a new operator, with \operatorname or
+\operatornamewithlimits, we want ' and * and - and / to be treated as
+ordinary text, not as math symbols. The same is true for . and :
+except that we would like a little space after them, so we have
+\newmcodes@ to temporarily change the \mathcode's of these symbols.
+
+
+\operatorname and \operatornamewithlimits both make \mathop's, using
+the new \mathocode's from \newmcodes@. \operatorname has \nolimits@
+at the end, to defeat any \limits typed after it, while
+\operatornamewithlimits simply has \nlimits@, which will be set
+either to \displaylimits or \nolimits@, depending on the style. The
+\kern 0pt is added because the argument might be just one symbol, and
+TeX's rules (TB, p. 443) imply that this symbol would be centered
+vertically around the axis.
+
+In all cases we use \fam\z@ instead of plain's \rm, since we will
+later change the meaning of \rm.
+
+
+\qopname@ and \qopnamewl@ are quick constructions, used to redefine
+\sin, \cos, etc., to have either \nlimits@ or \nolimits@ after them.
+
+
+\def\arccos, ..., \def\tanh redefine things using \qopname@ and
+\qopnamewl@.
+
+\inflim and \projlim are new; they are not in plain.
+
+
+\varinjlim, ..., \varlimsup are more complicated. Adjustments for
+\varinjlim, \varprojlim and \varliminf were made by eye. We don't
+bother about making these change size in subscripts, since they
+should never be used that way---the symbols would be too cramped to
+see. Notice that the \rm before the lim is NOT being used in math mode,
+so it is OK.
+
+
+\newdimen\buffer@ ...
+---------------------
+\ChangeBuffer allows the user to change \fontdimen13 \tenex. Since
+changes to \fontdimen's are global, the only way to allow the user to
+restore the original value, with \ResetBuffer, is to keep it in an
+inaccessible place, \buffer@. We also want \buffer as a place to
+store the current value of \fontdimen13 \tenex, since it is used in
+\shave and its relatives; the user is also supposed to be able to
+access \buffer, so it has no @.
+
+
+\def\shave ...
+--------------
+To shave the buffer space off the top and bottom of a symbol like
+\sum_{i=1}^n, we reset it with \fontdimen13 \tenex = 0pt, make a
+\mathop of this new symbol, and then reset \fontdimen13 to current
+value, stored in \buffer. To shave off the top buffer space only, we
+\topsmash the symbol, which leaves the bottom buffer space alone, add
+\vphantom{\shave{#1}} to get the right height, and make a \mathop of
+the whole thing.
+
+%1 We need \m@th from plain to shut off any \mathsurround. \m@th is
+ used similarly in many places, without further comment.
+
+\Invalid@\\
+-----------
+The \Sp...\endSp and \Sb...\endSb constructions, for multiline
+limits, is the first of many constructions based on \halign where we
+want to use \\ for line breaks, instead of the usual TeX primitive
+\cr.
+
+**********************************************************************
+\def\Let@
+---------
+This involves a TeXnical trick. In such constructions, we want to
+say \let\\=\cr. [Note that we want a \let here, and not simply
+\def\\{\cr}, because there is a big difference between a control
+sequence defined to be \cr, and \cr itself or something \let=\cr: a
+\cr (or & or \span) is immediately intercepted by TeX's scanner even
+when it is not expanding macros (TB, p. 248), while something defined
+as \cr will not indicate the end of a row until macros are expanded
+out. We will mention later one of the problems this can cause.]
+
+But if we happen to use \let\\=\cr within another such construction,
+as we certainly will want to do, then \\ will already be equivalent
+to \cr, and because of the way TeX parses things in an \halign, this
+\\ will immediately be used to stop the scanning of the element,
+leaving \let all by itself somewhere, and horrible error messages.
+As explained in TB, p. 386, the construction
+
+ \iffalse{\fi\let\\=\cr\iffalse}\fi
+
+circumvents this difficulty, because the { } hide the \let\\=\cr from
+the \halign, yet doesn't actually put it inside a group. Of course we
+need \relax first, in case this occurs at the beginning of an \halign
+(TB, p. 240). Since this is used so often, we have a special
+abbreviation for it.
+**********************************************************************
+
+
+\Invalid@\vspace, \def\vspace@
+------------------------------
+We want \vspace to be used only within certain constructions (all
+based on \halign). So we make it invalid in general, and let these
+constructions give the proper definition of \vspace. Since this
+happens so often, we abbreviate the definition of \vspace. We add
+\crcr before the \noalign in case the user forgets the \\.
+
+
+\def\multilimits@, ..., \def\endSp
+----------------------------------
+\Sb...\endSb and \Sp...\endSp will translate to ^{...} and _{...} for
+the very same construction {...}, which we call \multilimits@.
+
+This \multilimits@ construction is similar to many other
+constructions, like those for \matrix, \align, etc. We begin with
+\bgroup, which is almost like {, except that the matching \egroup,
+which is almost like }, needn't be in the same definition, but can
+actually be contributed by the \endSb or \endSp; then we define
+\vspace for use within this construction, and then we properly make
+\\ the same as \cr.
+
+Then comes something special. We want to get the same result from
+\Sb i\\ j\endSb as we would get with _{\scriptstyle i\atop
+\scriptstyle j}. The rules for making an \atop are somewhat
+complicated. They are stated in TB, p. 444, rule 15. For \atop, we
+have the parameters u=\fontdimen10 of the relevant math italic font,
+\scriptfont2; v=\fontdimen12 \scriptfont2; and phi=3\fontdimen8 of
+the corresponding symbol font, \scriptfont3. \atop is normally set
+with the numerator moved up by u and the denominator moved down by v,
+i.e., with \baselineskip=u+v. But if this makes them less than phi
+apart, they are set phi apart. This will be obtained by making
+\lineskiplimit and \lineskip equal to phi.
+
+
+\def\spreadlines
+----------------
+\Sp and \Sb are special sorts of alignments, but now we start the
+main ones. First of all, we want \spreadlines to be like \openup,
+except for consistency we want it to work as a macro taking an
+argument, rather than using the TeX assignment syntax. Also we want
+it to be used only in display mathematics; this means, in particular,
+that its effect will always be local to the display in which it
+appears.
+
+
+\def\Mathstrut@...
+------------------
+\Mathstrut@ is like \mathstrut, but only for \textstyle, the style we
+will be using it for in all our alignments. Whenever you trace
+through macros that involve \mathstrut, you get screens full of
+uninteresting stuff; it got so depressing that I decided to make
+\Mathstrut@ instead. We first make \Mathstrutbox@ an empty box, but
+with height and depth set to that of a ( in math mode.
+
+
+\newdimen\spreadmlines@ ...
+---------------------------
+In plain TeX, \matrix uses \normalbaselines to overrule any \openup's
+that have been used. We want to have a more general way of adjusting
+the spacing in a \matrix also. So we use \spreadmlines@ to store the
+desired amount to \openup in a \matrix. Like \spreadlines,
+\spreadmatrixlines should be used only in displayed mathematics; thus
+it will be local to the display in which it appears.
+
+
+\matrix is very much like \multilimits@, used before. However, now
+there are two \bgroups, corresponding to the {'s for \vcenter{ and
+\halign{; and \endmatrix contributes two \egroups. The combination
+\normalbaselines\openup\spreadmlines@ means that the \baselineskip is
+the normal one, unless \spreadmlines has been used (within the
+display the \matrix appears in) to change things. The effect of
+\Mathstrut@\crcr\noalign{\kern-\baselineskip} in \matrix is to insure
+that the first row is as tall as \Mathstrut@, and the one in
+\endmatrix makes the last row as deep. The purpose of this is to make
+sure that the height or depth of a matrix won't depend, for example,
+on whether the first row has tall letters, like A, or only short
+ones, like x --- so two similar matrices will usually line up right
+in formulas like <matrix1> = <matrix2>.
+
+There are two other new features. First, we put \, around the
+\vcenter; this looks better, especially with delimiters. The second
+feature is the \null before the first \, This is because of the rule
+regarding numbered formulas on TB, p. 189---if a very wide \matrix is
+used in a formula with a \tag, we don't want TeX to assume that we
+put glue before the \matrix in order to control its positioning with
+respect to that tag!
+
+
+\format...\\ is the construction that is used to allow a different
+preamble to be used in the \matrix. In all other AmS-TeX
+constructions, where such optional syntax is used, we use a
+\futurelet to see if this syntax is present. But it would be fatal
+to
+
+ \def\matrix{\futurelet\next\matrix@}
+
+because the \matrix might be used within another \matrix, and a \let
+within an \halign can cause havoc. This is hinted at in the
+next-to-last paragraph of TB, p. 248, although the viewpoint is
+different. The real problem arises when you have a \matrix
+containing another \matrix that happens to begin with & (because the
+first entry is blank). Just what does happen is complicated and
+interesting, but there's no point going into it here, since we are
+not going to be using a \futurelet. What we do instead is simply let
+\format end the \matrix (giving an empty matrix), and then start a
+new \matrix, with the appropriate preamble.
+
+**********************************************************************
+However, at this point we have to pull another TeXnical trick,
+somewhat like the one for \Let@, but different (see TB, p. 385). The
+construction
+
+ \iffalse{\fi\ifnum`}=0 \fi
+
+has balanced braces, so can appear within a \def. The same is true of
+
+ \ifnum`{=0 \fi\iffalse}\fi.
+
+As far as \halign is concerned, however, the first begins a group and
+the second ends one, so \format ... \\ looks to \halign like
+
+ \crcr\egroup [begin a new group] \format@ ...\\
+
+and thus as
+
+ \crcr\egroup [begin a new group]
+ make definitions [end the group] ...
+
+This is important, since otherwise the \\ will be interpreted as \cr
+if the \matrix is inside another \matrix, leading to havoc.
+**********************************************************************
+
+
+\newtoks\hashtoks@, ..., \def\format@
+-------------------------------------
+Having circumvented this difficulty, the idea is that \l&\r\\, for
+example, should be interpreted as $#$\hfil&\hfil$#$. Since #'s can
+usually appear only in special constructions, we want them to pop up
+as tokens, so we make a new token \hashtoks@ whose value is #. Then,
+if we define \preamble@ to be \l&\r, and define \l as
+{$\the\hashtoks@$\hfil}, etc., we can \edef\Preamble@{\preamble@} and
+\Preamble@ will have the desired result.
+
+Once the desired preamble is stored in \Preamble@, we still have to
+say \span\Preamble@ to have it be expanded (TB, p. 238, last two
+paragraphs). Notice that the \span\Preamble@ construction works when
+it is being used within a \def, even though we have single #'s
+instead of ##'s (normally an \halign within a \def needs ##'s instead
+of #'s). By the way, \show\hashtoks@ will actually give the result
+`##', but this is due to TeX's convention for printing token lists,
+see TB, p. 205, Exercise 20.7.
+
+
+\smallmatrix is a lot simpler, since we don't allow \spreadmlines,
+but essentially use \baselineskip=9pt (suitably adjusted using \ex@),
+don't worry about correcting the height of the first line or the
+depth of the last (since \smallmatrix'es aren't meant to be used
+together in formulas), and don't allow \format.
+
+
+\pmatrix, etc., are trivial.
+
+
+\hdots, for use within a \matrix, is plain's \ldots (which we change
+later).
+
+
+\newmuskip\dotsspace@
+---------------------
+The spacing in the \spacehdots...\for... macro will be a new mu-unit
+\dotsspace@, which we set to 1.5mu.
+
+
+\def\strip@, ..., \def\hdotsfor
+-------------------------------
+\spacehdots#1\for#2 macro should normally be used as
+
+ \spacehdots<number1>\for<number2>
+
+but it's quite conceivable that someone will type
+
+ \spacehdots{<number>}\for...
+
+even though the braces are unnecessary; in such a case TeX will
+actually consider the first argument to be {<number>}. So we don't
+want to specify the spacing simply as \mkern#1\dotsspace@, since this
+will be a syntactical error if #1 has braces around it. The macro
+\strip@ solves this problem. When argument #1 of \spacehdots is
+passed to \strip@, the braces are removed, but the space that
+delimits the argument is explicitly added. So if #1 is `3' or `{3}'
+or `{3 }' then we end up with `\strip@3 ' or possibly
+`\strip@3|_||_|' so we finally get `3\dotsspace@' or `3 \dotsspace@'.
+
+
+\multispan@ is just like \multispan from plain (TB, p. 243), except
+that we have an \unskip so that & \spaceinnerhdots ... will ignore
+the space after the &.
+
+
+\spaceinnerhdots needs the \strip@ trick for #2 also, since braces in
+\mscount={<number>} would be an error.
+
+
+\cases is easy since it is just made up of a \matrix, with a particular
+\format; we also want to \spreadmlines@\jot, and we put this inside a
+group, so that it will effect only the \cases, not another \matrix in the
+display.
+
+
+\newif\ifinany@
+---------------
+The line spacing in \aligned, \alignedat, \gathered, and \split is
+different from that in \matrix, because we want to \openup\jot. The
+problem, however, is that any of these might occur within one of the
+constructions \align, \alignat, \xalignat, \xxalignat, \gather,
+\multline, which already \openup\jot. So we need a flag, \ifinany@, to
+tell whether the construction is in any of these.
+
+
+\newif\ifinalign@
+-----------------
+For the purpose of deciding whether to \openup\jot, we also need a
+flag, \ifinalign@, to tell \split whether or not it is in an \align.
+
+
+\newif\ifingather@
+------------------
+Finally, because we allow a very special construction where \align
+appears in \gather (but within curly braces), we also need a flag,
+\ifingather@, to tell \align whether or not it is in a \gather.
+
+
+\strut@ is used as a quicker alternative for \strut, just as
+\Mathstrut@ was introduced as a shorter alternative to \mathstrut.
+We use \copy\strutbox@ rather than \unhcopy\strutbox@, because we
+will be using \strut@ in situations where we don't have to worry
+about entering horizontal mode. The dimensions of \strutbox@
+are determined by taking the baselineskip (we assume 12pt)
+and subtracting the lineskiplimit (1pt, set in AMSPPT.STY).
+
+
+\topaligned, \botaligned, and \aligned are practically the same, the
+first being a \vtop, the second a \vbox, and the third a \vcenter.
+
+
+\aligned@ is similar to \matrix, except we \openup\jot if we are not
+in a construction that sets \inany@true. Note that we put \strut@ in
+every line, since this is actually easier than putting it in only the
+first and last lines, and won't make any difference because of the
+\openup\jot. The main purpose of the \strut@'s in all the following
+constructions is so that when some of them are placed vertically
+above others (as they will be by certain other constructions) the
+spacing will still be correct. (Actually, the spacing won't always
+be exactly correct, if some lines contain extra tall or deep
+characters, but the discrepancies will be small, and in these cases
+one often has to add some extra spacing by hand anyway.)
+
+
+\alignedat is similar to \aligned, except that the preamble depends
+on the argument; we use \doat@ to produce this preamble, as
+\preamble@@, which we then reproduce, using \span\preamble@@.
+
+
+\newcount\atcount@, \def\doat@
+------------------------------
+\doat@, with argument n, first makes the token list \toks@ be
+
+ \hfil\strut@$\displaystyle{\the\hashtoks@}$&
+ $\displaystyle{{}\the\hashtoks@}$\hfil
+
+and then adds another n-1 copies of
+
+ &\hfil$\displaystyle{\the\hashtoks@}$&
+ $\displaystyle{{}\the\hashtoks@}$\hfil
+
+(the \strut@ isn't needed for these copies, only for the first one),
+using the method of TB, p. 373. This involves a \loop, and we use
+the counter \atcount@ to keep track of the number of iterations. If
+we then \xdef\preamble@{\the\toks@}, the resulting \preamble@ isn't
+yet the desired result, since we have \the\hashtoks@ appearing
+everywhere that # should appear, so we \xdef\preamble@@{\preamble@}
+to get the right result in \preamble@@.
+
+%1 Initialize \toks@.
+%2 Set \atcount@ to 1 less than #1.
+%3 Add \atcount@ copies of the other tokens.
+
+
+\gathered is much easier.
+
+
+This completes the aligned constructions that are treated as
+individual symbols, but leaves things like \align, in which each
+formula can have a \tag. So first we have to deal with \tag itself.
+
+
+\newif\iftagsleft@ ...
+----------------------
+Basically, \tag is supposed to mean \leqno or \eqno, depending on
+whether the flag \iftagsleft@ has been set. \TagsOnLeft sets
+\tagsleft@true, \TagsOnRight sets \tagsleft@false. The default is
+\TagsOnLeft. It seems reasonable to make these global, so their
+names have capitals in them.
+
+
+\newif\ifmathtags@ ...
+----------------------
+\tag has another slight problem, because \eqno and \leqno treat their
+arguments as math formulas, which isn't convenient when - is used as
+a hyphen; normally, it is better to have the argument treated as
+text. We will allow the argument to be treated both ways, depending
+on the flag \ifmathtags@. \TagsAsMath sets \mathtags@true, while
+\TagsAsText sets \mathtags@false, with the default being
+\TagsAsText. Again it seems reasonable to make these global, so
+their names have capitals in them.
+
+
+\tagform@ describes the formatting of tags desired by the style (more
+precisely the formatting desired when tags are treated as text). The
+default is to put tags in parentheses.
+
+[NOTE: TeX puts an \eqno or \leqno on a separate line unless the space
+between the tag and the formula is at least as wide as the tag
+itself, i.e., the formula plus a box twice the width of the tag
+should fit on the line. By diddling with \tagform@, this rule could
+be changed. For example, if the rule is that the space between the
+tag and the formula should be at least 1em (seems to be used by
+Cambridge University Press) we could
+
+ \def\tagform@#1{\setbox0\hbox{\rm(\ignorespaces#1\unskip)}%
+ \dimen0=\wd0 \advance\dimen0 1em \divide\dimen0 by 2
+ \wd0=\dimen0 \box0 }
+
+Then twice the width of \tagform@{#1} would be the `real' width of
+the tag plus 1em.]
+
+
+\thetag allows a fastidious user who wants to refer to `equation (3)',
+without being sure whether the style will use this particular format,
+to do so by typing `equation \thetag3'; the definition of \thetag has
+\leavevmode at the beginning, since \tagform@ is often an \hbox, and
+might begin a paragraph.
+
+
+\def\tag, \def\maketag@, ...
+----------------------------
+Finally, given a displayed formula $$ .... \tag ...$$, \tag has to be
+replaced by \leqno or \eqno, and ... has to be replaced by the proper
+formatting for this expression. The argument ... is everything from
+\tag to $$.
+
+\maketag@#1\maketag@ is basically just \tagform@{#1} (if tags are
+treated as text), but we also provide a mechanism for overriding the
+default formatting, by typing \tag "..." to get ... as the tag,
+exactly as typed. (This fits in with the scheme used in AMSPPT.STY
+for `literal' arguments to \footnote and \item in \roster's.)
+Compressed format isn't used since \tag's are used so often.
+
+%1 Let \tag be \leqno or \eqno.
+%2 Replace #1 by \maketag@#1\maketag@.
+%3 Finish off the displayed formula.
+
+%1 Here #2 is a possible space after the second " symbol; this
+ possible space is the reason for using the syntax where the
+ argument is delimited by a second \maketag@.
+
+
+\interdisplaylinepenalty from plain is used as a counter to store
+penalties for page breaks in alignments, but is initially set to
+10000, thus completely inhibiting such breaks.
+
+
+\allowdisplaybreaks should be used only within a displayed formula to
+set \interdisplaylinepenalty to 0 (perhaps a value like plain's 100
+would be better).
+
+
+\Invalid@\allowdisplaybreak, ..., \def\displaybreak@
+----------------------------------------------------
+We also want to use \allowdisplaybreak and \displaybreak to allow or
+force a break after a particular line of an alignment, but we want
+these control symbols to make sense only within these alignments, so
+we handle them like \vspace, etc.
+
+
+\Invalid@\intertext, \def\intertext@
+------------------------------------
+We want \intertext to produce \noalign'ed text, and again want this
+to make sense only with these alignments. The problem here is that
+when more than one line of text is produced, the height of the \vbox
+will be so large that only \lineskip glue would be used, not the
+proper amount to make the baseline of the first line of the \vbox the
+proper distance from the previous line. So instead of
+\vbox{\noindent##1} we use
+
+ \vbox{\null\noindent##1}
+
+Within this \vbox, the glue between the \null and the \noindent'ed
+paragraph will be just enough to make the space between the \null and
+the top line of the \vbox be \baselineskip. So we just have to put
+the \vbox on the list preceded by \nointerlineskip, to suppress any
+extra space.
+
+
+\centering@ is like plain's \centering, except that no shrinking of
+glue will be allowed, because we will regard such cases as overfull
+boxes that will either give error messages or be treated specially.
+
+
+\def\align
+----------
+$$\align... will essentially be an
+
+ $$\halign to\displaywidth{...
+
+unlike $$\aligned... which is essentially
+
+ $$\vcenter{\halign{ ... .
+
+Since the construction \halign to\displaywidth... without $$ at the
+beginning is actually allowed in TeX, but is quite different, we want
+to guard against errors by having \align give an error message if it
+is not being used within a displayed formula. However, we do allow
+the special construction {\align...\endalign} within a \gather. So
+we have \align give one construction in a \gather, but \align@ in
+display math mode, and an error message otherwise.
+
+**********************************************************************
+There is a special problem with \align, which has \endalign as part
+of its syntax, and so will all similar constructions. Basically,
+\align@ is supposed to call one control sequence, originally called
+\lalign@, if tags are on the left, another control sequence,
+originally called \ralign@, if tags are on the right, and yet a third
+control sequence, originally called \galign@, when it is in a
+\gather. Moreover, orginally these choices were made by setting
+\let\next@\lalign@, etc., and calling \next@. But if the user typed
+$$\align ... $$ without the \endalign, then at the end of the
+paragraph there would be an error message
+
+ ! Paragraph ended before \next@ was complete.
+
+which is totally incomprehensible (and the same for all such
+constructions). So, first of all, in such cases we use \def\next@
+instead of \let\next@. Moreover, we want the control sequence
+appearing in the error message to be known to the user. We will use
+
+ \csname align \endcsname
+
+as a substitute for \lalign@, which shows up on the screen as \align
+with only one extra space, and
+
+ \csname align \space\endcsname
+
+as a substitute for \ralign@, which shows up with two extra spaces.
+For the special case of \align with \gather, we use
+
+ \csname align (in \expandafter\eat@\string\\gather)\endcsname
+
+which just shows up as
+
+ \align (in \gather)
+
+(This happens to bomb in the special case
+
+ $$\gather {\align }\endgather$$
+
+with nothing on either side of the {\align}, but seems to work in
+most reasonable cases.)
+**********************************************************************
+
+In the definition of \align we \let\next@\align@, since \align@ will
+then call the other control sequences.
+
+
+\newhelp\andhelp@, ..., \def\align@
+-----------------------------------
+\align@ will set the flags \ifinalign@ and \ifinany@, and properly
+define \vspace, \allowdisplaybreak, \displaybreak, and \intertext.
+It will reduce to \align|_| when tags are on the left, otherwise
+\align|_||_|. These latter will essentially be \halign's, with two
+&'s per line; a line `lhs & =rhs \tag 3' will really be `lhs & =rhs &
+3'.
+
+In the special case of `lhs \tag 3', however, this line must become
+`lhs && 3'. So we will use a counter \and@ to record the number of
+&'s in the current line, and define \tag in terms of this number
+(\everycr will be used to set \and@ back to 0 at the beginning of
+each line).
+
+Moreover, if the user types `lhs &= rhs &= rhs', with or without a
+following \tag, then we want a more informative error message than
+`Misplaced alignment tab'. So we will let \tag set a flag \iftag@
+(with \everycr setting \tag@false), and have the tag part of the
+preamble give an error message if the flag hasn't been set. An extra
+& in a row will usually lead to chaos, and there's no point relying
+on TeX's decision to change the & to \cr; so we make the message
+strong, and add a help message, reiterating this.
+
+It is important to note that because we are \def'ing \tag to be
+something, and not simply \let'ing \tag=&, TeX's scanning mechanism
+would generally not properly intercept these hidden &'s as needed.
+Fortunately, that isn't a problem in this case, because the first two
+parts of the preambles for \measure@ and \align|_| and \align|_||_|
+do not involve # as an argument to a macro; so TeX isn't swallowing
+tokens blindly as it reads in the first two elements of each row of
+the \halign.
+
+
+\def\Tag@, ..., \def\measure@
+-----------------------------
+A whole new level of complication for \align is introduced by the
+fact that we want a tag automatically to be set on a separate line if
+it needs to be. There is no way to figure this out on a line-by-line
+basis, because the position of a line is influenced by all the other
+lines. So we will first `\measure@' our \align, to obtain three
+quantities: \maxlwidth@, the maximum length of the left hand side of
+all lines; \maxrwidth@, the maximum length of the right hand side of
+all lines; and \totwidth@ = \maxlwidth@ + \maxrwidth@.
+
+As we proceed through the lines, \lwidth@ and \rwidth@ will be used
+for the left hand length and right hand length of the current line.
+We apply \measure@ to everything up to the \endalign.
+
+Since \measure@ is used before anything else, we must catch the error
+of an extra & at that point. For convenience later on (in defining
+\alignat and \xalignat), we abbreviate the construction that
+supplies the error message, as \Tag@.
+
+%1 Initialize widths and \and@ to 0pt.
+%2 We just set a box, which we will not use.
+%3 We set \tag@false and reset \and@ to 0 at each \\ (which is
+ \let=\cr); \global needed since \noalign material is in
+ restricted vertical mode.
+
+%4 Each left hand side is just set in \displaystyle. \@lign is required
+ to make sure that if any such formula involves an \halign, the current
+ \everycr won't affect it.
+
+%5 Store width of entry in \lwidth@; \global needed since each entry
+ is essentially in its own group.
+
+%6 \maxlwidth@ is always largest of the \lwidth@'s found so far.
+
+%7 \and@ will be 1 at next entry.
+
+%8 \@lign needed here, as in %4.
+
+%9 Treat the right hand side similarly, getting maximum in
+ \maxrwidth@.
+
+%10 \and@ will be 2 at next entry.
+
+%11 The second &, if it is supplied by \tag, will simply throw away
+ the tag. But if it wasn't supplied by \tag, it will give an
+ error message.
+
+%11 Finally, make \totwidth@ = \maxlwidth@ + \maxrwidth@.
+
+
+**********************************************************************
+WARNING: Because \align processes its argument twice, you have to be
+careful if you are using an ad hoc construction in the form of a \box
+that just been set. This box must be used as \copy, rather than as
+\box, or it will be emptied out by the time \measure@ has gotten
+through with it!
+**********************************************************************
+
+
+\displ@y@ is just like plain's \displ@y, except that it also sets
+\and@ to 0 and \tag@false at each \cr (we need the \tag@false for
+certain later constructions, even though \align no longer needs it).
+
+
+\def\black@
+-----------
+Alignments do not show an overfull black box on any of their overfull
+rows (TB, p. 303). Since \align is just an \halign, this means that
+no black boxes would be shown when a row is overfull. To alleviate
+this problem, we at least arrange for a black box to show up at the
+last line of the alignment, by adding \black@\totwidth@ at the end.
+\black@#1, with any argument #1, simply backs up a line, and then
+adds some extra non-aligned empty material, which is specified as
+
+ \vbox{\noindent\hbox to#1{\strut@\hfill}}.
+
+This makes a \vbox that contains a paragraph starting (and containing
+only) a box of width #1 and height and depth of \strut@; if #1 >
+\hsize, then this paragraph has an overfull box in it, which will
+produce the desired black line, of height and depth of \strut@
+(unless \NoBlackBoxes has been specified). However, we will add this
+box only if #1 > \displaywidth (which could conceivably be larger
+than \hsize).
+
+%1 Save \prevdepth in \dimen@, and then inhibit interline glue with
+ \nointerlineskip (which just sets \prevdepth=-1000pt).
+
+%2 Back up enough to put in line with height of \strut@.
+
+%3 Put in the overfull \vbox.
+
+%4 Restore \prevdepth.
+
+
+\expandafter\def\csname align \space ...
+----------------------------------------
+Since \align|_||_| is created with \csname ... \endcsname, we have to
+use an \expandafter\def construction. \align|_||_| produces the
+\align when tags are on the right. We first \measure@ to find
+\maxrwidth@ and \totwidth@. Our display will be centered within a
+region of width \displaywidth,
+
+
+ <---------------------------\displaywidth------------------------>
+ | xxxxxxxxxxxxxx = yyyyyyyyy |
+ | xxxxxx = yyyyyyyyyyyyyyyyy |
+ | xxxxxxxxx = yyyyy<------------L------------>|
+ |
+ <------------\totwidth@---------->
+
+ <--left margin-> <-right margin->
+
+
+so the left and right margins will each be
+
+ 1/2(\displaywidth-\totwidth@).
+
+The tag for a line (say line 3 in the above picture) can go on that
+line if the length L is at least twice as big as the tag's length.
+We have
+
+ L = (right margin) + \maxrwidth@ - (\rwidth@ for this line).
+
+So we need
+
+ 1/2(\displaywidth-\totwidth@)+\maxrwidth@-(\rwidth@ for the line)
+ >= (twice tag length).
+
+When the tag has to be put on a separate line, we basically just
+replace the tag by a two-line box with an empty first line and the
+tag on the second line.
+
+[NOTE: Diddling with \tagform@ (and hence with \maketag@) will
+change the rules for the tags here just as with \tag itself.]
+
+[NOTE: Since \align computes \lwidth@ and \rwidth@ at each line, it
+is easy to add commands that use knowledge of these widths. For
+example, suppose that one wants formulas like
+
+ a = xxxxxxxxxxxxxxxxxxxxxxxxxxxx
+ + yyyyyyyyyyyyyyy
+
+where the y...y is set flush right with the x...x instead of being
+indented some fixed amount. To type this as
+
+ \align a & = xxxxxxxxxxxxxxxxxxxxxxxxxxxx \\
+ & \flushright {+yyyyyyyyyyyyyyy} \\
+
+we could introduce a new dimension \prevrwidth@ to store the \rwidth@
+of the previous line and let \flushright#1 mean
+
+ \hbox to\prevrwidth@{\hfil#1}}
+
+(To get this to work correctly, we would probably need to add
+
+ \global\prevrwidth@\rwidth@
+
+to the \everycr{\noalign{...}} clause.)]
+
+%1 \measure@, set \and@=0.
+
+%2 Use \displ@y@, except if in a \gather just set \and@=0 at each
+ \cr.
+
+%3 Left hand formulas in the \halign to\displaywidth will have
+ \tabskip\centering@ glue before them to push them to the right.
+
+%4 \@lign required so that an \halign in a left hand formula will
+ not have the \tabskip\centering@ affect it.
+
+%5 As we go through the lines once again, we set \lwidth@ to the
+ length of the current left hand side, as before, except now we
+ also print this left hand side (\box0 ).
+
+%6 Tabskip glue is zero between the two sides.
+
+%7 \@lign needed here, as in %4.
+
+%8 We set \rwidth@ to the length of the current right hand side,
+ but now also print right hand side.
+
+%9 Right hand formulas have \tabskip\centering@ glue after them to
+ push them to the left.
+
+%10 First we store the \tag in \box0. \@lign required in case the tag
+ involves an \halign!
+
+%11 Let dimen0 = 1/2(\displaywidth-\totwidth@)+\maxrwidth@ - \rwidth@.
+
+%12 If not enough space for tag on this line, we \llap a two-line box
+ with first line empty, and tag on the second line.
+
+%13 If there is enough space we just \llap the tag.
+
+%14 \tabskip glue is 0 after the tag.
+
+%15 Now do all the lines.
+
+%16 Finally, add black box if \totwidth@ > \displaywidth.
+
+
+\newdimen\lineht@, \expandafter\def\csname align \endcsname ...
+---------------------------------------------------------------
+\align|_| is similar, except that our calculations for whether the
+tag fits will involve \maxlwidth@ and \lwidth@. Moreover, when the
+tag has to be set on a separate line, we need to replace it by a
+two-line box with the tag on the first line and an empty second line.
+This empty second line has to have the same height as the line to
+which the tag applies, so we need a dimension \lineht@ to store this
+height in.
+
+%1 \displaywidth@ is max of \totwidth@ and \displaywidth.
+
+%2 Record height of left hand side in \lineht@.
+
+%3 Update \lineht@ to height of right hand side, if it's bigger.
+
+%4 The \kern-\displaywidth@ moves the tag back over to the left (to
+ the left margin of the page, unless \totwidth@ is greater than
+ \displaywidth@ [so that our display is actually overfull], in
+ which case it is moved to the left margin of the display).
+
+
+\expandafter\def\csname align (in ...
+-------------------------------------
+In the case where \align was in a \gather, it reduced to a control
+sequence called
+
+ \align (in \gather)
+
+We simply make this a \vcenter{\align@...} (where \align@ will reduce
+to\align|_| or \align|_||_|).
+
+
+\Invalid@\endalign
+------------------
+Notice that \endalign is quite different from \endaligned, because
+the latter actually ends a group, whereas \endalign is just used as
+the delimiter for the argument of \align. This could cause great
+difficulties if we needed \align ... \endalign within a group that
+has other \\ constructions. Fortunately, the only such case is
+\align ... \endalign within a \gather, and we simply insist that
+braces are used around the \align ... \endalign in this case. But we
+ought to do something more than just leaving \endalign undefined.
+
+
+\newif\ifxat@
+-------------
+\alignat and \xalignat have much in common, so we will write their
+definitions similarly, using \ifxat@ as a flag to do things
+differently for the \xalignat.
+
+
+\alignat first checks to make sure we are in display math mode, and
+then calls \alignat|_| (created by \csname...\endcsname), which uses
+\endalignat as part of its syntax. In the case of \alignat, the test
+for tags on the left or right is made afterwards, so we don't need
+separate names for the two possibilities.
+
+
+\newif\ifmeasuring@, \newbox\savealignat@
+-----------------------------------------
+In `\alignat|_| n' the argument n determines how many &'s are allowed
+per line, namely 2n (2n - 1, plus 1 for the \tag). This in turn
+determines how many &'s have to be added when a \tag appears in a
+line with fewer &'s, and when an error message should be given: if
+\tag appears in a column where \and@ has value k, then we need to add
+2n-k &'s; if we have k > 2n, then the \tag part of the preamble
+should give an error message.
+
+We won't try to set tags on separate lines automatically, but we do
+want to produce a black box if lines are too long, so we still need
+to measure things. Instead of separately calling a \measure@ type of
+argument, we will use a flag \ifmeasuring@ to determine if we are
+measuring or actually typesetting the alignment; the appropriate
+preamble will be made by \attag@, which will depend on \ifmeasuring@
+(and on \ifxat@). When measuring, we will save the result in the box
+\savealignat@.
+
+
+\expandafter\def\csname alignat \endcsname ...
+----------------------------------------------
+
+%1 #1 is the number after \alignat, #2 is everything else.
+%2 First we are just measuring.
+%3 We make the proper preamble with \attag@.
+%4 Then we are actually typesetting.
+%5 We make a new preamble with \attag@.
+%6 Then we typeset all the lines.
+%7 Finally we add a black box if necessary.
+
+
+\endalignat, like \endalign, has no definition of its own.
+
+
+\xalignat, like \alignat, first checks to see that we are in display
+math mode, and then calls \xalignat|_|, since it has \endxalignat as
+part of its syntax.
+
+
+\xalignat|_| is exactly the same as that for \alignat|_|, except that
+we have \xat@true (which will influence \attag@, when building the
+preambles).
+
+
+\attag@ finally builds the preamble. Although the process is similar
+to that used for building the preamble for \alignedat, it is
+complicated by the fact that we have to include \maketag@ and \Tag@
+among the tokens and make sure that they aren't expanded out when we
+do our \xdef's.
+
+%1 Store \maketag@ in \Maketag@ and \Tag@ in \TAG@.
+
+%2 Insure that \maketag@ and \Tag@ won't be expanded.
+
+%3 The preamble will be written in terms of \llap@ and \rlap@, which
+ are simply \llap and \rlap when we are typesetting, but when we
+ are measuring will be a box twice the width of the tag.
+
+%4 \toks@ will be the first part of the \preamble; it acts slightly
+ different for \xalignat|_| and \alignat|_|.
+
+%5 \toks@@ will be the final part of the \preamble; it differs
+ significantly for \xalignat|_| and \alignat|_|.
+
+%6 We use a \loop to add on pieces of the preamble to \toks@.
+
+%7 Then we add on the last part.
+
+%8 Then we do one more \xdef, as with \alignedat.
+
+%9 Finally, we restore the meaning of \maketag@ and \Tag@.
+
+
+\endxalignat also has no definition.
+
+
+\xxalignat is simpler, because we don't have to worry about tags at
+all. First we make \xxalignat call \xxalignat|_|, since it uses
+\endxxalignat as part of its syntax, in display math, but gives an
+error message otherwise.
+
+
+\xxalignat|_| is similar to \alignat|_| and \xalignat|_|, except we
+don't bother about measuring things, since we don't have to worry
+about tags.
+
+
+\xxattag@ is used to make the preamble, rather than \attag@.
+
+
+\endxxalignat also has no definition.
+
+
+\newdimen\gwidth@, \newdimen\gmaxwidth@
+---------------------------------------
+\gather is naturally easier than \align, but we still have the
+problem of putting the \tag on a separate line, so we still have to
+measure things. But we need only the one quantity \gmaxwidth@, the
+maximum width of all the formulas; \gwidth@ is the width of each line
+as it is measured.
+
+
+\gmeasure@ is analogous to \measure@ for \align@.
+
+
+\gather gives an error message if we are not in display math mode,
+and otherwise calls either \gather|_| or \gather|_||_|, since both
+use \endgather as part of their syntax.
+
+
+\gather|_||_| is analogous to \align|_||_|.
+
+
+\gather|_| is analogous to \align|_|, using the \glineht@ instead of
+\lineht@.
+
+
+\newif\ifctagsplit@ ...
+-----------------------
+It seems more elegant if a \split ... \endsplit formula has its tag
+either at the left of the top line or the right of the bottom line,
+but we will allow the tag to be centered, depending on the flag
+\ifctagsplit@. We provided \CenteredTagsOnSplits and
+\TopOrBottomTagsOnSplits to allow the user to set the flag. The
+default is \TopOrBottomTagsOnSplits.
+
+
+\split will be \outsplit@ if it is not in some other alignment, but
+if it is in some other alignment it will be \insplit@, which is the
+interesting thing. We don't need to worry about the
+\csname...\endcsname trick here because \split doesn't actually use
+\endsplit as part of its syntax. The K-method wouldn't work in this
+multi-case situation.
+
+
+\insplit@ just starts setting \box0 as \vbox{\halign{... with the
+proper format.
+
+
+\endpslit then finishes \box0 and calls either \lendsplit@ or
+\rendsplit@.
+
+
+\def\rendsplit@
+---------------
+For tags on the right, we need to get out the last line of the
+\insplit@, which is a \vbox made up of the various lines of the split
+formula, with glue between them. If TG represents various tabskip
+glues (which all happen to be 0pt) and HF represents various glues
+added by the \hfil's in the preambles, this box looks like
+
+ ....
+ ....
+ \hbox{TG\hbox{HF lhs}TG\hbox{rhs HF}TG}
+ <interline glue>
+ \hbox{TG\hbox{HF lhs}TG\hbox{rhs HF}TG}
+
+
+%1 \box9 now has everything in \box0 except the last line, which is
+ now \box8, and the interline glue that preceded the last box,
+ which is removed by \unskip. \box8 is now of the form
+
+ \box8 = \hbox{\TG\hbox{HF lhs}TG\hbox{rhs HF}TG}.
+
+#2 In \box1 we \unhcopy8. \unskip removes the last TG. Then \box2
+ becomes \hbox{rhs HF} (\box 2 is saved by \global). The next
+ \unskip removes the middle TG. Then \box3 (also saved by \global)
+ becomes \hbox{TG{HF lhs}}. Notice that the width of \box3 is the
+ same as the width of the whole left part of the split (the TG is
+ 0, but the HF fills out all lines to the same width, [even though
+ lhs is actually usually empty in a split]).
+
+%3 Finally, \box7 is now the right side of the last line, set to its
+ natural width (the HF glue at the end having been removed by
+ \unskip).
+
+Now we will define \split@ to be the proper repositioning of
+elements.
+
+%4 Suppose our \split is within an \align, and we want tags centered
+ on the \split.
+
+%5 Then we make \split@ be one more line of the form LHS & RHS, where
+ RHS is a \vcenter of the whole split (\box0 ) except moved left by
+ width of \box3, which is the width of the whole left hand side.
+ This means that the symbols that the \split were aligned along
+ will now align with all the other symbols in the \align. We also
+ make LHS an empty box with the same width as the whole left hand
+ side, so that \split will still have the proper width.
+
+%6 Otherwise, we want the tag on the last line, so we have \split@
+ add two lines: one having \box 9 (everything in the \split except
+ the last line and interline glue) on the right, except moved over
+ to the left the right amount, the width of \box3; and another
+ having \box3 on the left and on the right \box7, which is the
+ proper right side (cut down to its natural width). The proper
+ interline glue will then be added back between these two lines.
+
+%7 If we're not in an \align, so don't need to worry about lining up
+ with other things, we do similar, but simpler, things, without
+ worrying about moving things over.
+
+%8 And finally, having defined \split@ correctly, we insert it.
+
+
+\def\lendsplit@
+---------------
+For tags on the left we have to proceed somewhat differently. We
+can't conveniently obtain the first line, but we can begin by making
+a \vtop out of our \vbox:
+
+%1 \box9 is just like \box0, except baseline is that of first line.
+
+%2 Now \box8 is last line.
+
+%3 Now \box3 is as before (but \box2 hasn't been saved, because we
+ don't need to find the natural width of the last right side).
+ \box1 is just a scratch box, so can be used twice like this.
+
+Now we define \split@.
+
+%4 Suppose our \split is within an \align, and we want tags centered
+ on the \split.
+
+%5 Then we make \split@ be one more line of the form LHS & RHS, where
+ RHS is a \vcenter of the whole split, except with a new baseline
+ (\box9 ) and moved left the right amount, and LHS an empty box as
+ before.
+
+%6 Otherwise, we want the tag on the first line, as before.
+
+
+\outsplit@ is just reduced to \insplit@.
+
+
+\newdimen\multlinegap@
+----------------------
+Finally, we come to \multline. We store the gap between the margins
+and the left and right sides of the \multline in a dimension
+\multlinegap@.
+
+
+\newdimen\multlinetaggap@
+-------------------------
+For \multline we use the rule that there must be at least
+\multlinetaggap@ space between the formula and the tag. (This seems
+more reasonable than the usual rule, since the formula doesn't have
+to be centered.)
+
+
+\MultlineGap globally changes \multlinegap@.
+
+
+\multlinegap can only be used in a displayed formula, and then
+affects only this formula.
+
+
+\nomultlinegap is an abbreviation for \multlinegap{0pt}.
+
+
+\multline first checks to see that we are in display math mode, and
+calls \multline@ if we are. There is no point using the
+\csname...\endcsname trick here, because eventually we use the syntax
+\endmultline$$, so if the \endmultline is missing, at the end of the
+paragraph we just get an error message about a missing $ sign.
+
+
+\newif\iftagin@, \def\tagin@
+----------------------------
+\multline@ has to be processed differently depending on whether or
+not the displayed formula it appears in has a \tag. We use a flag
+\iftagin@ to tell us, and test with \tagin@.
+
+
+\multline@ first does the \tagin@ test and then calls either
+\multline@l or \multline@r.
+
+
+\newdimen\mwidth@, \def\rmmeasure@
+----------------------------------
+When tags go on the right, we will need to measure the last line of
+the \multline, and store its width in \mwidth@. This is easily done
+with \rmmeasure@; we set \mwidth@ to the width of each line, so that
+its final value is just the width of the last line.
+
+%1 Don't worry about what \shoveleft and \shoveright really are,
+ since we only care about the result of the last line, which
+ shouldn't have either.
+
+
+\newdimen\mlineht@, ..., \def\lmmeasure@
+----------------------------------------
+When tags go on the left, however, we will need to measure the FIRST
+line of the \multline, again storing its width in \mwidth@ (we will
+also need to store its height, in \mlineht@). This is more
+complicated, and we actually need two new flags, \ifzerocr@ and
+\ifonecr@, to keep things under control.
+
+%1 After the first \cr, which is the one that follows the preamble,
+ we have \zerocr@false and \onecr@true. Then after the first \\ in
+ the \multline, we always have \onecr@false (and also
+ \zerocr@false). So \onecr@true holds only for the first line of
+ the \multline.
+
+
+\newbox\mtagbox@, ..., \newdimen\rtwidth@
+-----------------------------------------
+We will need to store the tag in a box \mtagbox@. And \ltwidth@ and
+\rtwidth@ are dimensions where we will store the widths of this box,
+for use with \shoveleft and \shoveright; however, \ltwidth@ will be
+made 0pt when a tag on the left can't go on the same line as the
+formula (since in this case we want \shoveleft to shove all the way
+to the left), and similarly for \rtwidth@.
+
+
+\multline@l calls \lmultline@@ if there is a \tag, and \lmultline@@@
+otherwise. In the latter case, it first sets \mtagbox@ to \null, and
+makes \ltwidth@ and \rtwidth@ be 0pt.
+
+
+\lmultline@@ sets other values for \mtagbox@, \ltwidth@, and
+\rtwidth@ when there's a \tag, and then simply calls \lmultline@@@.
+
+%1 \mtagbox@ is a box with the tag in it.
+
+%2 \dimen@ is
+
+ (width of first line) + (width of tag) + \multlinetaggap@.
+
+%3 \ltwidth@ is just the width of the tag, unless the tag won't fit
+ on the line (determined by \dimen@>\displaywidth), in which case
+ it is 0pt (because the tag won't really be there!).
+
+
+\lmultline@@@ mainly has to define \shoveright and \shoveleft.
+\shoveright is simple: the \hfilneg cancels the \hfil normally on the
+right, but we add \hskip\multlinegap@, so that the line will come out
+the same distance from the right margin as the last line. \shoveleft
+is more complicated. First of all, we put \hfilneg at the beginning,
+to cancel the \hfil. Then, if \ltwidth@ isn't 0pt (so that the tag
+is actually on the line), we \hskip the width of this tag plus the
+\multlinetaggap@ (the total space from the margin to the beginning of
+the first line); but if \ltwidth@ is 0pt, so that the tag is on a
+separate line, we just \hskip the \multlinegap@. Unfortunately, this
+doesn't quite do it, because the formula that we are applying
+\shoveleft to might begin + A + B + ... for example. Our preamble
+for the \multline involves $\displaystyle{}#$, so that the initial +
+sign will have a medium space between it and the A. But there is
+also a medium space BEFORE the + sign, so the + sign will not really
+line up correctly on the left. To get around this, we set our
+formula with {} before it in \box0 and without the {} before it in
+\box1. When a symbol like + begins the formula, the difference
+between the width of \box0 and the width of \box1 will be two of
+these thick spaces, so we exactly cancel out any extra space with
+\hskip.5\wd1 \hskip-.5\wd0.
+
+%1 First define \shoveright and \shoveleft.
+
+%2 We begin the \multline with a separate line starting with
+ \hfilneg, to cancel the \hfil.
+
+%3 Suppose first that there is a tag.
+
+%4 Moreover, suppose it will fit on the first line.
+
+%5 Then we put in the tag, and skip the proper gap.
+
+%6 But if it won't fit on the first line, we manufacture a box
+ containing the tag on top and an empty box the height of the first
+ line on the bottom.
+
+%7 If there isn't a tag, we just skip the \multlinegap@.
+
+
+\multline@r works just like \multline@l.
+
+
+\rmultline@@ works just like \lmultline@@.
+
+
+\rmultline@@@ works like \lmultline@@@, except that now we don't
+have to worry about the tag yet, which will be taken care of by the
+\endmultline. However, now the definition of \shoveright is a little
+more complicated to take into account whether or not the tag goes on
+the same line as the last line; the definition of \shoveleft is
+simpler, but we still have to do the same trick to take care of
+formulas like + A + ... .
+
+
+\endmultline works slightly differently for tags on the left and tags
+on the right, so we have it call either \lendmultline@ or
+\rendmultline@.
+
+
+\lendmultline@ is trivial.
+
+
+\rendmultline@ has to put in the tag.
+
+%1 Suppose there is a tag.
+
+%2 Suppose, moreover, that it will fit on the last line.
+
+%3 Then we skip the proper gap before the tag, and put in the tag.
+
+%4 But if it won't fit on the last line, we manufacture a box
+ containing an empty box on the first line, and the tag on the
+ bottom line.
+
+%5 If there isn't a tag, we just skip the \multlinegap@, before
+ adding the \hfilneg.
+
+
+\bmod, ..., \mod are easier. \bmod is exactly as in plain, but with
+\fam\z@ instead of \rm. And \pmod is also based on plain, except
+that more space seems to look better in displays. \pod is the same
+as \pmod, but without the word `mod', and \mod is similar, except
+without the parentheses, and slightly different spacing.
+
+
+\newcount\cfraccount@, ..., \def\rcfrac
+-----------------------------------------
+Next come continued fractions. TeX's \over construction
+
+ {...\over\displaystyle ... +
+ {\strut ... \over\displaystyle ... ...}}...}
+
+is admirably suited for a recursive definition, since each new level
+contributes one left brace, with all the right braces occurring at
+the end; we just have to keep track, in a counter \cfraccount@, of
+how many levels we have entered. However, it doesn't look good if TeX
+puts the usual \nulldelimiterspace around each of the subfractions,
+so we will actually have one more level around each subfraction, with
+\nulldelimiterspace subtracted inside it. Thus, each \cfrac will
+contribute two \bgroup's.
+
+We also have to make \\ mean \over\displaystyle inside the \cfrac. In
+case the \cfrac appears in some other construction where \\ has been
+\let=\cr, we use the usual \iffalse{\fi...\iffalse}\fi trick to
+enclose this definition. \lcfrac is just like \cfrac, except that the
+next \\ will put \hfill before the \over (hence at the end of the
+next numerator); and \rcfrac puts in the \hfill before the numerator.
+
+
+\def\gloop@, \def\endcfrac
+--------------------------
+Finally, \endcfrac puts in pairs of }'s, with
+\hskip-\nulldelimiterspace between them. A \loop...\repeat type of
+construction is meant to be used here, in which we decrease
+\cfraccount@ by 1 at each step. But there is a complication, because
+\loop uses \def\body to keep track of things, and after each
+iteration we are two levels up, so that \body is no longer defined
+(it might even be some old definition of \body!). So we have to use
+\gloop@, which is just like \loop, except that it uses \gdef\body.
+
+
+\def\binrel@
+------------
+For \overset and \underset, we want a way to check whether a symbol S
+is either a binary operator or a binary relation, since \overset and
+\underset are supposed to preserve this. The idea is to compare the
+formula $S$ (with \mathsurround=0pt) and the formula ${}S{}$. To
+make the comparison both independent of the present values of
+\thinmuskip, etc., and easy, we set the formulas with
+\thinmuskip=0pt, \medmuskip=1mu, \thickmuskip=-1mu.
+
+The spacing between the \mathord {} and a binary operator is
+\medmuskip, between {} and a binary relation is \thickmuskip and
+between {} and anything else is either 0 or a \thinmuskip. So, S must
+be a binary operator if the formula gets wider, and a binary relation
+if the formula gets narrower. Instead of saving the results of the
+test in control sequences, we just make \box2 have the width of {}S{}
+minus the width of S, and check on the width of \box2, since this
+test will always be done right at the beginning of any construction.
+
+
+\overset and \underset are essentially as in plain, except we make
+the result a binary operator or relation if it started as one; we
+also add the \kern\z@ as in \operatorname, in case only a single
+letter is involved.
+
+
+\oversetbrace and \undersetbrace are simply convenient abbreviations.
+
+
+\def\sideset
+------------
+In a construction like \sideset ^+ \and ^* \to \sum, the final symbol
+will look like {\vphantom{\sum}}^+ {\sum}^* --- with the \vphantom
+used to get the prescript ^+ at the right height. To get the limits
+in the right place, we need a construction like that used for
+multiple integrals: \hskip-<...>\mathop{\hskip<...>{\vphantom } }
+where the correction <...> is the width of {\sum}^* which we set in
+\box2, minus the width of \sum with the prescript, which we set in
+\box1.
+
+
+\rightarrowfill@, ..., \def\leftrightarrowfill@ depend on the math
+style, to modify \overrightarrow and \overleftarrow from plain so
+that they work in all styles, using \mathpalette. The \smash- is
+used because the height of the minus sign happens to be the height of
+the plus sign (thus, larger than you'd like).
+
+
+\overrightarrow, ..., \underleftrightarrow are now defined, using
+\overrightarrow@, ..., \underleftrightarrow@ for use with
+\mathpalette.
+
+
+Now we come to \dots, which is probably the most complicated thing in
+all of AmS-TeX!
+
+We would like \dots to know what to do on the basis of the next
+token, which we can get with a \futurelet. (It turns out that we
+don't happen to encounter any problems if we have \dots & within a
+\matrix, etc. This can be explained only by serendipity.) If that
+next token is a comma, then we will use \dotsc. If it is the token
+\not, then the \not presumably cancels a binary operator, so we will
+use \dotsb@ [\dotsb@ is essentially \dotsb, except that \dotsb will
+look ahead to see if extra space should be left because the next
+symbol might be a right delimiter]. If the next token is +, =, <, >,
+-, * or : then we again want to use \dotsb@.
+
+Otherwise, however, it's not clear what to do with the token. For
+example, we can't simply make a formula containing only that token,
+since it might be something like \matrix that doesn't make any sense
+by itself (we don't have this problem with \underset and \overset,
+since they are actually applied to arguments, which must be
+meaningful formulas).
+
+The only hope at this point is actually to look at the next token in
+detail, using \meaning!!
+
+When we look at \meaning<token> we might get
+
+ \mathchar"... or macro...->...
+
+(Remember, however, that all the characters here will have type 12.)
+
+If we get \mathchar"... the number ... is of the form xnnn, where x
+gives the ``class'', with 2 for a binary operator and 3 for a binary
+relation. So if we set a counter to the number and divide by 4096,
+the value will be 2 and 3 for binary operators and relations,
+respectively.
+
+If we get macro...->... then we don't want to go berserk and actually
+try to figure the macro out, but if the definition begins with \not
+we should use \dotsb (remember that \ne, for example, is a macro that
+expands to \not=). Moreover, we ought to use \dotsb if the definition
+begins with \mathbin or \mathrel.
+
+In addition, if we test to see whether the definition begins with
+\DOTSB we can use \DOTSB as a signal that we are using a binary
+operator (and the user can add this to a definition also). Later we
+will add \DOTSB to certain of plain's definitions, since this will be
+the only reasonable way to see that they represent binary operators
+or relations. For example, \longrightarrow begins with \relbar, and
+\Longrightarrow with \Relbar. We have simply added \DOTSB in front
+of both. \DOTSB has also been added previously to the various big
+operators, so that \dotsb will be used before them.
+
+Similarly, \DOTSI will indicate that \dotsi should be used, for dots
+before an integral sign.
+
+Once \dots has figured out whether to use centered or low dots, it
+will still try to figure out whether some extra space should be left,
+because the next symbol is a right delimiter. Here we will find
+\DOTSX useful, to be put into a macro definition to indicate that it
+represents a right delimiter.
+
+
+\let\DOTSI\relax, ..., \let\DOTSX\relax
+---------------------------------------
+Initially, these are all simply \relax.
+
+
+\newif\ifmath@, {\uccode ...
+----------------------------
+First we make a flag to tell that \meaning begins with \math, where
+\ m a t h are all of type 12. To do this we have to use the \uccode
+trick, temporarily setting the \uccode of various numbers and of !
+(all of which are type 12) to \ m a t and h, so that when we
+\uppercase them we will get type 12 \ m a t and h. We will use
+\math@___\math@ to test ___ and set \ifmath@ true if the first five
+symbols are \ m a t and h, storing what remains in \meaning@. We are
+going to be applying constructions like \math@, which takes at least
+5 arguments, to the unknown ___ and then sometimes yet another
+construction taking at least 5 arguments, so, as will appear later,
+we will always add ten periods (any other symbol would do as well) to
+___ before we begin the whole testing process.
+
+(This construction assumes that ! is of type 12. If some macro
+pacakge changes this [for French punctuation, say], then the ! should
+be replaced by some other symbol that is guaranteed to be of type
+12.)
+
+
+\newif\ifmathch@, {\uccode ...
+------------------------------
+When something begins with `\math', we will further test to see if it
+is followed by ch??" (we don't bother testing the ? characters, since
+no other result of \meaning could be like this). The test is of the
+form \mathch@___\mathch@, setting \ifmathch@ true if it passes, and
+then storing the " and what comes after in a new \meaning@.
+
+
+\newcount\classnum@, \def\getmathch@
+------------------------------------
+Next we define a control sequence to test whether the "____
+combination we've picked up begins with 2 or 3, by computations with
+the hex number `"____' Since we've added periods, we must be careful
+to pick up only the number before the first period. At this point we
+no longer store the result, but directly define \thedots@ [the main
+thing that \dots is trying to produce] to be \dotsb@ if we do have 2
+or 3.
+
+
+\newif\ifmathbin@, {\uccode ...
+-------------------------------
+When we test whether a macro meaning begins with \mathbin or
+\mathchar we will first use the above \math@ test to see if it begins
+with \math. Then we will have to test if it is followed by `bin'.
+But we actually have to test whether it is followed by `bin|_|'
+(since someone might have defined a new control sequence beginning
+\mathbin...). Spaces created by \meaning still have their usual type
+10, so we will use \space@ for this part of the test, picking up the
+token after `bin' with a \futurelet. Compressed format is used here.
+The final result of the test is flagged by \ifmathbin@.
+
+
+\newif\ifmathrel@, {\uccode ...
+-------------------------------
+Similarly, we test for \mathrel.
+
+
+\newif\ifmacro@, {\uccode ..., \def\macro@@
+--------------------------------------------
+To test whether \meaning begins with `macro', we just test for the
+`mac', since no other possible result of \meaning could begin like
+this. The test sets \ifmacro@ and stores the result in (a new)
+\meaning@, which uses \macro@@ to isolate the part after the ->,
+i.e., the actual macro definition.
+
+
+\newif\ifDOTS@, \newcount\DOTSCASE@, {\uccode ...
+-------------------------------------------------
+To test whether a macro definition begins with \DOTSB or \DOTSI or
+\DOTSX we first test for the \DOTS, with \DOTS@...\DOTS@. If it
+doesn't we just set \ifDOTS@ false, otherwise we further test for the
+`B|_|' or `I|_|' or `X|_|', setting \ifDOTS@ true if the test is
+passed, and setting a counter \DOTSCASE@ equal to 0, 1 or 2 in these
+cases.
+
+
+\newif\ifnot@, {\uccode ...
+---------------------------
+This is the test for whether something starts with \not.
+
+
+\newif\ifkeybin@, \def\keybin@
+------------------------------
+We abbreviate the process of checking for all the possible binary
+operators and relations that can be entered from the keyboard.
+
+
+\def\dots
+---------
+Finally, we're ready to define \dots ! which is different in text and
+math.
+
+
+\def\tdots@
+-----------
+In text, we want to ignore spaces before \dots, and we want to leave
+an extra thin space if the next token, which we get with a
+\futurelet, is a , or . or ; or : or ? or ! Otherwise (another letter
+or symbol comes next) we want to leave an ordinary space.
+
+
+\def\mdots@, \def\mdots@@
+-------------------------
+Finally, in math mode we want \mdots@, which uses \futurelet to get
+the next token. Compressed format isn't used here, because things
+are confusing enough already.
+
+The main aim of \mdots@@ is to define \thedots@, which will be used
+at the very end. We begin by defining \thedots@ to be \dotso@ (the
+dots before ordinary symbols), and then modifying it under the stress
+of various tests. The order has been chosen so that the more
+complicated tests come near the end.
+
+Notice that the \xdef\meaning@{\meaning\next..........} is allowed,
+even if \next happens to be outer.
+
+%1 By default, we use \dotso@.
+
+%2 If \boldkey (explained below) happens to come next, then we simply
+ want to swallow up the \boldkey and use \boldkeydots@ instead.
+
+%3 Similarly, if \boldsymbol happens to come next, then we simply want
+ to swallop up the \boldsymbol and use \boldsymboldots@ instead.
+
+%4 Otherwise, if , comes next we use \dotsc.
+
+%5 If \not comes next we use \dotsb@.
+
+%6 If +, =, etc., comes next we use \dotsb@.
+
+%7 Otherwise we want to look at \meaning applied to the next token;
+ we get this by \xdef\meaning@{\meaning\next..........} where the
+ extra periods are added for reasons explained above. We also
+ make another copy, \meaning@@, for later use.
+
+%8 If \meaning@ begins `\math', we further test for ch??"; if this
+ test is passed we use \getmathch@ to define \thedots@.
+
+%9 Otherwise we see if we have a macro. We test on \meaning@@,
+ since the previous test has already changed \meaning@.
+
+%10 Suppose we do have a macro (so that \meaning@ is now the part
+ after ->).
+
+%11 We see if the macro begins with \not. If it does, \thedots@
+ is \dotsb@.
+
+%12 Otherwise, we see if the macro begins with `\DOTSB' or `\DOTSI'
+ or `\DOTSX', and if so, we set \thedots@ to \dotsb@ for \DOTSB
+ and \dotsi for \DOTSI.
+
+%13 Otherwise we still have to see if the macro definition begins
+ with \mathbin or \mathrel. Once again, we see if it starts with
+ \math, storing the remainder in the new value of \meaning@.
+
+%14 If it does we see if it really begins \mathbin and choose \dotsb@
+ if it does (the test doesn't change the value of \meaning@).
+
+%15 Otherwise we also see if it really begins \mathrel, and choose
+ \dotsb@ if it does.
+
+
+Now that we've gotten to \thedots@, which is either \dotsc or \dotsi
+or \dotso@ or \dotsb@ or \boldkeydots@ or \boldsymboldots@, we have
+to define these.
+
+
+\plainldots@, \plaincdots@ are used to store away plain's definitions
+of \ldots and \cdots.
+
+
+\dotsi and \dotsb@ are simple.
+
+
+\newif\ifextra@, ..., \def\rightdelim@
+--------------------------------------
+But \dotso@ is supposed to leave extra space if followed by a right
+delimiter, so it is more complicated.
+
+We use \ifextra@ to say if extra space should be left, after results
+of a test on \next, which a \futurelet will let equal the next token.
+For simplicity, first we simply test if the next token is an obvious
+right delimiter, storing the result in \ifrightdelim@, and then we
+make the real test.
+
+%1 \rightdelim@ is true if
+%2 \next is ) ] \rbrack ...
+%3 or \Biggr, but false otherwise.
+
+
+\extra@ is the real test to set \ifextra@.
+
+%1 \ifextra@ is true if the \rightdelim@ test is passed.
+
+%2 It is also true if a $ sign comes next.
+
+%3 Otherwise we look at \meaning again.
+
+%4 Suppose we have a macro.
+
+%5 Then if it starts with \DOTSX, \ifextra@ is again true.
+
+
+\newif\ifbold@, \dotso@
+-----------------------
+\dotso@, the most common result of \mdots@, has to act specially
+if it was called by \boldkeydots@ or \boldsymboldots@, which
+will be signalled by the flag \ifbold@.
+
+In the standard case, where \ifbold@ is false, we just want to
+use a \futurelet to get the next symbol, use \extra@ to test
+this symbol for a right delimiter, and then use \plainldots@,
+followed by \, if the next symbol is a right delimiter. If this
+were the only case to consider, we could use the definition
+
+ \def\dotso@{%
+ \DN@{\extra@\plainldots@\ifextra@\,\fi}%
+ \FN@\next@}
+
+But when \ifbold@ is true, the next symbol will already have been
+scanned by \boldkeydots@ or \boldsymboldots@, and stored in
+\delayed@. In this case, we don't want to use a \futurelet, but
+simply want to apply \extra@ with \next being \delayed@.
+
+So when \ifbold@ is true we \let\next\delayed@ and then define
+\nextii@ to be this combination, but if \ifbold@ is false we define
+\nextii@ to be the whole combination \DN@{\extra@...}\FN@\next@}, and
+then we call \nextii@.
+
+
+\def\extrap@
+------------
+
+We still haven't defined \dotsc, which will actually be the last kind
+of dots we define, and there's also \dotsb and \dotso (as opposed to
+\dotsb@ and \dotso@) and similarly \ldots and \cdots.
+
+\dotsb, \dotso, \ldots, and \cdots are slightly different from
+\dotso@ and \dotsb@, because they might be used before , or . or :
+especially at the end of a displayed formula that ends with
+punctuation, since that punctuation would have to appear before the
+$$ signs. So we want extra space here also.
+
+We use \extrap@, which takes as argument another (dot producing)
+macro. It is used as an abbreviation for a construction that puts an
+extra thin space before a , or . or ; as well as something that
+passes the \extra@ test.
+
+
+\ldots and \cdots use \extrap@, and of course must have low and
+centered dots, respectively.
+
+
+\dotso is just \ldots, and \dotsb is just \cdots, although other
+styles could change that. Similarly, \dotsm is \dotsb in this style.
+
+
+\dotsc, however, is a little special because we DON'T want extra space
+if it's followed by a comma---someone might have typed \dotsc,
+instead of simply \dots---so we have to explicitly check for only
+a ; or .
+
+
+\cdot should be treated as an ordinary symbol by \dots. We can
+arrange for this by using the fact that \dots doesn't check a macro
+definition for \mathchar!
+
+
+\longrightarrow, ..., \iff need to have \DOTSB added to their plain
+definitions.
+
+
+\dddot, ..., \spvec have nothing special. A lot of adjustment was
+done by eye.
+
+
+\textonlyfont@ is just a control sequence to allow us conveniently to
+redefine \rm, \it, \sl, \bf, \smc, etc.
+
+
+\oldnos will be used instead of \oldstyle, which doesn't fit in this
+scheme; in fact, \cal and \oldstyle and \mit will be made
+\undefined at the end. \oldnos is just a control sequence with an
+argument; as a convenience, it doesn't leave extra spaces around
+commas that might occur in the number.
+
+
+\text in text is basically just an \hbox, but allowed to begin a
+paragraph; in math it will be \text@, which is much more complicated.
+Actually, \text should also reset \mathsurround if this has a non-zero
+value, just in case \text is used within a math formula that appears in
+some construction where \m@th has been used.
+
+
+\def\mathhexbox@, ..., \def\P
+-----------------------------
+Once \text@ is defined, it will be possible to create symbols that
+can be used in either math mode or in text mode without $ signs,
+because \text{$...$} will always change sizes right. With this in
+mind, we redefine \dag, etc., from plain so that they change sizes
+automatically. \mathhexbox@ is the obvious modification of plain's
+\mathhexbox. An extra set of braces is inserted, so that ^\dag, etc.,
+will work.
+
+
+\newif\iffirstchoice@, ..., \def\text@
+---------------------------------
+\text@ will be a \mathchoice; in each case we will simply set an
+\hbox, but we will specify the style that we want for our math
+formulas and also which fonts we want for \rm, etc. This involves a
+few details, but there is also a detail of another sort that needs to
+be attended to.
+
+Conceivably, someone could use \footnotemark (which is actually
+defined in AMSPPT.STY, rather than in AMSTEX.TEX) within \text (so
+that, together with \footnotetext, a footnote could be set on some
+text within a displayed formula). \footnotemark increases the
+counter \footmarkcount@, and since a \mathchoice is set four times,
+\footmarkcount@ would be increased by 4, instead of by 1. To get
+around this, we let the flag \iffirstchoice@ normally be true but set
+it to be false in all but the first part of the \mathchoice for
+\text@, and in AMSPPT.STY we only advance the counter \footmarkcount@
+when \iffirstchoice@ is true.
+
+Aside from this, we will use \everymath to set the style at each
+size, and the control sequence \textdef@@ will be used to select the
+proper text fonts; depending on its argument, T, S or s, it will
+choose the \textfont or \scriptfont or \scriptscriptfont for each
+family of fonts. We also redefine \textfonti and \textfontii to be
+the proper size of families 1 and 2, for any text macros that use
+these. (At present that includes \{ and \} in text, which are fairly
+important, as well as \t and \AmSTeX.)
+
+
+\textdef@@ simply uses \textdef@ for each of the families, \rm, \bf,
+\sl, \it we need. If another family is added that should work
+properly in \text, the appropriate clause should be added here.
+
+
+\def\rmfam{0}, \def\textdef@
+----------------------------
+\textdef@ works under the assumption that \bf has a corresponding
+\bffam, \sl a corresponding \slfam, etc., all with names obtained by
+adding `fam' to the font change name. We therefore have to define
+\rmfam to be 0. If a new font, say \bfit, is introduced,
+\newfam\bfitfam should be used to create a new family with the
+corresponding name.
+
+To get the name of the family, e.g., \bffam, from the name \bf of the
+font, \textdef@ uses
+
+ \csname\expandafter\eat@\string\bf fam\endcsname.
+
+Then it redefines the font name \bf to be the \textfont for \bffam if
+the first argument is T, or the \scriptfont for \bffam if it is S,
+etc. The \relax is needed because \bffam is just a number, after the
+\edef.
+
+
+\scriptfont\itfam ...
+---------------------
+Any family that will be used with \text@ should have some assignment
+for its \scriptfont and \scriptscriptfont; otherwise there will be
+error messages even if only text or display size is being used,
+because a \mathchoice actually sets all four possibilities.
+\sevenit, etc., are not defined in plain. If \sevenit, etc., are
+available, then they can be used here, or in amsppt.sty.
+
+
+\foldedtext, \topfoldedtext, and \botfoldedtext, like \smash and
+\phantom, use one basic definition, with flags \iftopfolded@ and
+\ifbotfolded@.
+
+
+\foldedwidth is syntax that has to be looked for. We don't store the
+\foldedwidth, which is .3\hsize by default, anywhere special, but use
+it as soon as we get it.
+
+
+\def\bold ...
+-------------
+Next come the control sequences for changing fonts in math mode. The
+reason for defining \bold@ in terms of \bold@@, instead of directly,
+is that later on we will sometimes want to change the definition to
+eliminate the extra set of braces, and this is easily done by saying
+\let\bold@=\bold@@. \relax is added after \fam\bffam, etc., because
+these families are just numbers.
+
+
+\Cal@@ has \noaccents@ for reasons that will appear later.
+
+
+
+\mathchardef\Gamma ...
+----------------------
+We make the upper case Greek letters ordinary symbols instead of
+variables, because we don't change them with font change
+instructions.
+
+
+\mathchardef\varGamma ...
+-------------------------
+The variant upper case Greek letters are exactly the same, except "00
+is replaced by "01, since they are on the math italic font, which is
+family 1.
+
+
+
+\newif\ifmsamloaded@ ...
+------------------------
+Originally, \loadmsam, \loadmsbm, and \loadeufm were created because
+the msam, msbm and eufm fonts are not available to everyone, so
+instead of loading them directly, we defined control sequences to
+load them; we also needed to set flags so that AMSPPT.STY will know
+whether to load in the corresponding fonts for the eightpoint size.
+
+Now, \loadmsam, \loadmsbm, and \loadeufm are considered part of
+AmS-TeX, but we keep the same structure, since other font families
+are treated this way.
+
+We will later have a list, \fontlist@, in the form of TB, p. 378,
+that is supposed to list all the fonts used. To make sure that any
+fonts loaded are added to this list, instead of \font we use \font@,
+which is defined later. When we load in fonts for a family we also
+want to use \newfam to create the family name, but \newfam is \outer,
+so we would need an inner version, or the code itself. But there is
+another problem here; we want the allocations we make to use the
+present definition of \alloc@, for proper use of \showallocations. So
+we use \alloc@@ for the present meaning, and then write the code for
+\newfam in terms of \alloc@@.
+
+
+\def\hexnumber@ ...
+-------------------
+We will need to use various family numbers in \mathchar and
+\mathchardef's. But we need the hexadecimal values if any family is
+greater than 9, so we use \hexnumber@ to get it. An \ifcase is most
+efficient here.
+
+In addition to the family number of new families that we will load,
+we will also need to use the family number of the family \bffam, so
+we use \bffam@ to stand for its hexadecimal number. We \edef\bffam@,
+rather than \def'ing it, so that if someone is loading in AMSTEX.TEX,
+instead of using a format file, succeeding definitions will take less
+time.
+
+\loadmsam and \loadmsbm set flags to say they are loaded, declare the
+necessary fonts, create the corresponding new families, assign the
+fonts to these families, and create \msam@ and \msbm@ for the
+hexadecimal numbers of these families.
+
+In addition, once the msam fonts are loaded we will let
+\dashrightarrow, ..., \dasharrow (which use \dabar@), and \ulcorner,
+..., \maltese be defined, because they are defined specially. All
+other symbols can be handled by \newsymbol, explained below.
+
+Similarly, we will redefine plain's \widehat and \widetilde to take
+advantage of wider symbols in the msbm fonts, but these will not be
+used unless the msbm fonts are loaded.
+
+
+\newsymbol
+----------
+We don't want \loadmsam or \loadmsbm to introduce names for all the
+symbols, since this will use up too many control sequence names
+needlessly. Instead we let \newsymbol be used in the form
+
+ \newsymbol\nleqslant 230A
+
+or, more generally,
+
+ \newsymbol\cs 230A
+
+where \cs is the user's choice of a control sequence, and the
+4-character ``ID'' 230A should be listed along with the ``standard''
+name \nleqslant in the list of symbols. The first character of this
+ID will be 1 for symbols on the msam fonts, and 2 for symbols on the
+msbm fonts.
+
+For \newsymbol we first \define the control sequence to be empty, to
+get an error message if it is already defined. Then we let \next@ be
+\relax, but change \next@ to \msamfam@ if #2 is 1 and the msam fonts
+are loaded or to \msbmfam@ if #2 is 2 and the msbm fonts are loaded.
+Then, if \next@ is still \relax we give error messages; otherwise we
+do a \mathchardef, using the values of \next@.
+
+
+\UseAMSsymbols
+--------------
+For people who want to use the AMS's names, \UseAMSSymbols will
+\input the file amssym.tex.
+
+This file begins with \catcode`\@=11 (so that it can use the tests
+\ifmsamloaded@, \ifmsbmloaded@). If these families are loaded, it
+uses \newsymbol with the standard names for all the symbols on the
+fonts. However, it does this within a group where \globaldefs=1 so
+that these names will be globally made, even if \UseAMSsymbols is,
+for some reason, used within a group. We must \undefine
+\rightleftharpoons, \angle, and \hbar before using them with
+\newsymbol, since they are already defined.
+
+At the end, the file makes @ \active again.
+
+If the families aren't loaded we give error messages, and we also
+first add \catcode`\@\active, so that @ will be certain to be active.
+
+
+If the \msbfam is loaded, we can use \Bbb, just like the other font
+change instructions; like \Cal, it has \noaccents@, which will be
+explained later.
+
+
+Though defined here, \loadmsam, \loadmsbm and \loadeufm must actually
+appear later, after \font@ has been defined.
+
+
+\frak has been added for changing to the \eufmfam in math mode.
+Similarly, any other added families of fonts should be treated like
+this, if their characters are basically just specified by typing
+letters.
+
+\goth is just a convenient alternative for \frak.
+
+
+\ifcmmibloaded@ ...
+-------------------
+Next comes the mechanism for loading the two families of bold fonts,
+cmmib and cmbsy. We will have a single control sequence \loadbold
+for loading both, but separate flags for telling when each family is
+loaded (so that users who know what they are doing and who decide to
+load only one family [or only certain sizes of a family] can still
+use subsequent control sequences).
+
+\mathchari@, \mathcharii@ simply give \mathchar's if the first,
+respectively second, family of bold symbols is loaded, otherwise
+error messages.
+
+
+\boldkey
+--------
+\boldkey basically has to test all the various possiblities for
+``keys'' that come after it.
+
+We can test for a letter by using \ifcat\noexpand#1A; in this case we
+just use #1 in \fam\cmmibfam if it is loaded, and give an error
+message otherwise.
+
+Otherwise, we first test individually for ! ( ) + : ; = ? [ ] and
+use the appropriate symbol on the \bf fonts.
+
+After this test, we test individually for , - . / < > * | and use
+the appropriate symbol on the appropriate bold fonts, specifying them
+with \mathchari@ or \mathcharii@, to get error messages if the fonts
+aren't loaded.
+
+Finally, we test for the digits 0, ..., 9, and simply replace them
+with \bold0, ..., \bold9, already defined (\boldkey isn't supposed to
+be used with digits, but if it is we might as well revert to \bold).
+
+
+\def\boldsymbol ...
+-------------------
+\boldsymbol is much more complicated, since we will have to look at
+\meaning.
+
+We begin by defining \next@ to be an error message; it will be
+changed to \relax whenever we reach a case where \boldsymbol can be
+used. (Eventually, alternate error messages may be defined.)
+
+Again, we first test for letters, and use \fam\cmmibfam in this case,
+unless this family isn't loaded, in which case we just give a special
+error message (and let \next@ be \relax, so that the original error
+message isn't given).
+
+Then we do some of the same manipulations with \meaning#1 as in
+\dots. If we had a \mathchar, we will use \boldsymbol@@ on the value
+of \meaning@ (instead of the \getmathch@...\getmathch@ from \dots).
+
+Some of the things we want to use with \boldsymbol are defined as
+delimiters, so if we don't have a \mathchar, we have to use \macro@
+from \dots, together with a new construction \delim@, defined below,
+to see if this is the case, and if so, we will use \delim@@ with
+\meaning@.
+
+Finally, if none of these tests are passed, we will still use a final
+test, \boldsymbol@, for certain exceptional symbols.
+
+
+\mathhexboxii@ is just \mathhexbox@ for the cmbsy family, but an
+error message if this family isn't loaded.
+
+\boldsymbol@, the final check, just examines individual possiblities,
+and defines the result in terms of \mathcharii@ or \mathhexboxii@ or
+\bffam@, in the case of \lbrack and \rbrack (if they are used instead
+of [ and ], which would be used with \boldkey.)
+
+
+\boldsymbol@@#1.#2\boldsymbol@@ is going to be applied
+where #2 are the remaining .'s from \meaning@, and #1 is
+the hexadecimal number after the \mathchar.
+
+%1. We set both \classnum@ and \count@@@ to #1.
+
+%2. We divide \classnum@ by 4096 to get the first hexadecimal
+ digit (first from the left), and set \count@ to this value.
+
+%3. Then we multiply \count@ by 4096, and subtract from the
+ original value, \count@@@, so that \count@@@ now has the
+ value of last three hexadecimal digits. We also set
+ \count@@ to this value.
+
+%4. Then we divide the new \count@@@ by 256 to get the second
+ hexadecimal digit, which we store in \count@.
+
+%5. Then we multiply the second hexadecimal digit, \count@@@,
+ by 256 and subtract from \count@@, which still has the
+ value of the last three hexadecimal digits, so that
+ \count@@ now has the value of the last two hexadecimal
+ digits.
+
+%6. Then we divide \count@@@ by 256 again, so that it has the
+ value of the second hexadecimal digit.
+
+%7. Finally, we multiply \classnum@, the first hexadecimal
+ digit, by 4096 again and add \count@@, the last two
+ hexadecimal digits to it. So if the hexadecimal digit was
+ "abcd, \classnum@ is now "a0cd, and \count@@@ = b.
+
+%8. Now, if \count@@@ = 0, so that our symbol came from family
+ 0 (i.e., the roman fonts, which should mean that our symbol
+ was one of \Gamma, ..., \Omega), we want to use the
+ corresponding symbol in the \bf family, which means that it
+ is \mathchar"axcd, where x is the number for \bffam, so we
+ get this by adding 256 times the hexadecimal number \bffam@
+ to \classnum@, and then using \mathchar\number\classnum@.
+
+%9. On the other hand, if \count@@@ = 1, so that our symbol
+ came from family 1 (i.e., the math italic fonts), then we
+ want to use the corresponding symbol in the cmmib family,
+ so we add 256 times the hexadecimal number \cmmibfam@ to
+ \classnum@ and use \mathchar\number\classnum@, except that
+ we give an error message if these fonts aren't loaded.
+
+%10. Similarly if \count@@@=2 (in which case our symbol came
+ from family 2 (i.e., the math symbol fonts).
+
+
+\newif\ifdelim@ ...
+-------------------
+\delim@#1\delim@ sees if #1 starts with \ d e l; if so, it makes
+\ifdelim@ true and sets \meaning@ to be the rest.
+
+When \delim@@#1"#2#3#4#5#6\delim@@ is used, #2 will be the type of
+delimiter, #3 will be the font family the symbol occurs on, "#4#5
+will be the location of the symbol on the font, and #6 will be
+everything else (i.e., the large variant, if there is one). If #3
+isn't the second family, we stick with the original error message
+that \boldsymbol can't be used with this symbol; otherwise we let
+\next@ be \relax, so that we won't get this error message, and then
+either produce the symbol, with \mathcharii@#2#4#5, or else give an
+error message if the family isn't loaded.
+
+
+\vert, \Vert (and \|) and \backslash have to be redefined so that the
+initial hexadecimal digit 0 is specifically added, in order for the
+definition of \delim@@ to work (plain simply leaves out the 0).
+
+
+\boldkeydots@#1 and \boldsymboldots@#1 are called if \dots is
+followed by \boldkey or \boldysmbol.
+
+In both cases, we first make \ifbold@ true, and then set \next to be
+#1. The value of \next will be used by \mdots@@ to decide whether to
+use \dotso@, etc. If \dotso@ is used, then we need to reset \next to
+#1, for use by \ifextra@, so we first store #1 in \delayed@, and
+include \let\next\delayed@ in the definition of \dotso@. After the
+dots are put in by \mdots@@, we then put in the right symbol with
+\boldkey#1 or \boldysmbol#1, and finally set \ifbold@ to be false
+again.
+
+On subtle point: in \boldkeydots@, the = after \let\next and
+\let\delayed@ are required, because #1 might be = , in which case it
+would disappear, so that \next would be set to \let, or \delayed@ to
+\mdots@@, etc., resulting in no end of mischief.
+
+
+\newif\ifeufbloaded@ ... \newif\ifeurbloaded@ ...
+-------------------------------------------------
+The next five sets of definitions make it easy to load the rest of
+the Euler fonts, one at a time, when needed. The user should take
+care not to try to load too many at once, as TeX's limit of 16
+families cannot be changed.
+
+
+\def\accentclass@, ..., \makeacc@\bar
+-----------------------------------
+We change the definition of \hat, etc., so that constructions like
+\bold{\hat A} will use the bold \hat symbol. But we want \Cal{\hat A}
+and \Bbb{\hat A} to use the usual \hat symbol, since these fonts
+don't have accent characters. That is why we added \noaccents@ to
+the definitions. The strategy is to change \hat from
+\mathaccent"705E to \mathaccent"\accentclass@05E, where \accentclass@ is
+usually 7, but is redefined as 0 when \noaccents@ is in force. To
+save space we use \makeacc@ to produce these definitions.
+
+
+\vec is different, as the accent itself is on only one font
+(\textfont1).
+
+
+\newcount\skewcharcount@, ..., \def\theskewchar@
+------------------------------------------------
+Now come definitions of \Hat, etc., which will get double accents
+correctly positioned. After \dots, these are the most complicated
+things in AmS-TeX.
+
+TeX properly places single accents over letters in math mode by using
+the kern, s, between the letter, L, and the \skewchar for its font
+(TB, p. 443); we have to emulate this procedure. The results of the
+instructions in Rule 12 on p. 443 can be obtained by replacing L by
+{L\hskip 2s}, putting (i.e., centering) the accent over this box, and
+then adding \hskip-2s.
+
+This means, first of all, that we have to find the \skewchar of the
+font. The \skewchar is -1 or '177 for the fonts in plain, but might
+be anything; however, we assume that the \skewchar for all the fonts
+in any particular family are the same. Moreover, we assume that the
+kerns are proportional in different size fonts within a family, so
+that the kern in the \textfont for the family is all we need to know.
+(This seems to give quite adequate results for the Computer Modern
+fonts.)
+
+The control sequence \theskewchar@ globally sets \skewcharcount@ to
+the \skewchar for the family if it is between 0 and 127, and to -1
+otherwise. We use \global because \theskewchar@ will be used within
+an \hbox. If the \skewchar is between 0 and 127, \theskewchar@ will
+also produce the \skewchar character for the font. This character can
+be obtained as \mathchar.... where .... is (the \skewchar for the
+family) + (256 times the family number) + (4096 times the class),
+where we should take the class to be 7 (variable), so that \mathchar
+will select whatever family we are in.
+
+TeX always sets \fam to -1 at the beginning of a formula. This means
+that we should assume that our character is in family 1 (where the
+ordinary letters lie), unless \fam has a different value between 0
+and 15.
+
+%1 First assume that \fam=-1, so that our letter is in family 1, and
+ set \familycount@ to 1, and set \skewcharcount@ to the \skewchar
+ for family 1.
+
+%2 But if \fam has a legal value, between 0 and 15, so that our
+ letter is in this \fam, set \familycount@ to this value, and
+ \skewcharcount@ to the \skewchar for this \fam.
+
+%3 If \skewcharcount isn't between 0 and 127, just set
+ \skewcharcount@ to -1. Otherwise add 256 times \familycount@ to
+ the \skewchar, and then add 28672 (= 7 x 4096), and produce this
+ \mathchar.
+
+
+\newcount\pointcount@, \def\getpoints@
+--------------------------------------
+The construction \getpoints@...\getpoints@ will be applied to things
+like \the\dimen0. If \the\dimen0 is 23.456pt, \pointcount@ will be
+set to 23, the integer number of points in \dimen0. The use of . in
+the syntax for \getpoints@ is OK, since constructions like
+\the\dimen0 always produce the decimal point.
+
+
+\newdimen\accentdimen@, ..., \def\dimentomu@
+--------------------------------------------
+Eventually, we will use \theskewchar@ to store the kern between our
+letter and the \skewchar in a dimension register \accentdimen@. We
+will use the control sequence \dimentomu@ to convert this to mu's and
+store the number of mu's in a counter \accentmu@, so that we can use
+\accentmu@ mu to get a kern that varies appropriately with the style
+of the formula.
+
+Essentially, we want to multiply the number of points by 1.8, since
+there are 18 mu in 10 points. Since we are going to deal in whole
+numbers, we will actually multiply by 1800 and divide by 1000. In
+the definition below, multiplying \accentdimen@ by 100 first lets
+\getpoints return a good value.
+
+
+\def\Makeacc@
+-------------
+Finally, we are ready to produce \Hat, etc., with \mathaccent@, the main
+thing left for us to define. As with ordinary accents, we use a
+control sequence to abbreviate the constructions, and incorporate
+\accentclass@ to take care of the case where letters come from a font
+that doesn't have accent characters.
+
+
+\unbracefonts@ temporarily changes the meanings of \rom, \bold, etc.,
+so that the extra pair of braces isn't included.
+
+
+\def\mathaccent@
+----------------
+
+%1 First we store the current family in \thefam@; as usual, it is set
+ to 1 if it is -1, i.e., if \fam hasn't been changed yet.
+
+%2 We initialize \accentdimen@ to 0pt; it may have been changed by a
+ previous \Hat, etc.
+
+%3 Now we set the formula #2 in the current family (and in
+ \textstyle). \unbracefonts@ isn't really important here, but we
+ put it in for consistency, since it will be needed in a
+ corresponding box later on.
+
+ Although we initialized \accentdimen@ to 0pt, it may have changed,
+ because #2 might already involve a \Hat, etc. In fact, we will
+ later arrange explicitly for this to happen in such a case.
+
+%4 If \accentdimen@ hasn't changed, the accent is simple.
+
+%5 But we will globally make \accentdimen@ different from 0pt, so
+ that a \Hat applied to this new accented character will be treated
+ differently, via the clause after the final \else in this
+ definition. Moreover, we will globally set \accentmu@ to the
+ number that we want to be used for this new accented character:
+
+ %5a \box1 is the formula #2 followed by the \skewchar for the font
+ (or by nothing, if the \skewchar isn't between 0 and 127).
+ Here \unbracefonts@ is needed if #2 is something like \bold X:
+ we don't want the extra braces around the \fam\bffam X,
+ because we want \fam to be \bffam when \theskewchar@ does its
+ thing.
+
+ %5b \box2 is the \skewchar alone (or nothing). It is in the right
+ family, because \skewcharcount@ was most recently globally set
+ in box 1.
+
+ %5c \accentdimen@ is now the kern between #2 and the \skewchar.
+
+ %5d We double it, change to mu's, and add 1 for good measure.
+
+%6 If we're in the case where \accentdimen@ was changed, we use the
+ value of \accentmu@ that was created to properly position the
+ accent. We make the whole result an ordinary symbol, and add an
+ empty group so that things like \Hat{\Hat A}^2 will work OK.
+
+
+\Makeacc@ ...
+-------------
+Now we make all these accents.
+
+
+\Vec is special, as with \vec.
+
+
+\def\newbox@, \def\accentedsymbol
+---------------------------------
+We want \accentedsymbol to create a \newbox to store the symbol.
+Since \newbox is \outer, we need an inner version (we can't simply
+use the code, because we are going to be using it after
+\expandafter).
+
+The \newbox created by \accentedsymbol\Ahathat{\Hat{\Hat A}} will
+just be called \Ahathat@box, which we create with
+\csname...\endcsname.
+
+
+\def\sqrt ...
+-------------
+\radical, \underline and \overline are like ^ and _ : they operate on
+the next <math field> rather than on the next macro argument (TB, p.
+291). So, for example, \underline\noteq becomes \underline\not=
+which underlines only the \not, and \underline\notin gives mysterious
+error messages. To avoid this, we redefine \sqrt, \underline and
+\overline as control sequences with arguments.
+
+
+\Invalid@\leftroot, .., \def\plainroot@
+---------------------------------------
+\root will have both \leftroot and \uproot as possible parts of its
+syntax. The definition is messy because we allow them to occur in
+either order. We also have to worry about skipping over spaces after
+a right brace after \leftroot{...} or \rightroot{...}. The net
+result of all the mess is simply to assign values to the counters
+\uproot@ and \leftroot@.
+
+\root actually begins working with the code on the last line: it
+starts a group (to keep the values of \uproot@ and \leftroot@ local,
+for \root's within \root's), initially sets \uproot@ and \leftroot@
+to 0, and after \uproot@ and \leftroot@ have been properly assigned,
+it calls \plainroot@, which is almost exactly the same as plain's
+\root, except the \mathchoice involving \r@@t has to be written out,
+rather than using \mathpalette, in order to get the final \egroup in
+the right place.
+
+And \r@@t is like plain's \r@@t, except that we add corrections for
+the values of \uproot@ and \leftroot@. For \leftroot@ we simply
+change the \mkern-10mu between the root and the main quantity by
+\mkern-10mu\mkern\leftroot@ (i.e., we leave more room between them,
+since \leftroot@ is the amount to move the root to the left); we have
+to correct for this extra shift with \mkern-\leftroot@ mu at the
+beginning.
+
+\uproot@ is handled a little differently, since mu is a unit for
+horizontal distances, not vertical ones. We set a box of width
+w=\mskip\uproot@ mu, and increase \dimen@, the amount involved in
+raising the root, by 10/6 w. (Then, since we raise by .6\dimen@, the
+extra amount we are raising is w.)
+
+
+\boxed makes a box with rules of width .4\ex@ (so .4pt at 10 points),
+and we want its baseline to be the baseline of the original formula.
+The \vbox on lines 3--5 of the definition surrounds \box0, the
+original formula in \displaystyle, with three points of space and the
+rules on all sides. It is now too high by 3pts + .4\ex@ + depth of
+\box0 (since the construction \vbox{\vskip3\ex@\box\z@\vskip3\ex@}
+produced a box of depth 0). So we lower by that total amount.
+
+
+\let\amspersand@\relax
+----------------------
+Now come commutative diagrams. The diagrams themselves aren't much
+of a problem, and the interesting things are the arrows within them.
+It is pleasant that one can avoid using & in commutative diagrams, by
+having the arrows put the &'s in themselves; the only problem is that
+the same construction used for horizontal arrows in commutative
+diagrams is also supposed to work for individual arrows in math mode.
+The way to do this is to have the macros contain \ampersand@ in the
+right places, where \ampersand@ is usually \relax, but can be changed
+to & within a commutative diagram.
+
+
+\newdimen\minaw@ ...
+--------------------
+We also want the arrow constructions to give different lengths for
+arrows within commutative diagrams and for individual arrows in math
+mode (except that in either case the arrows will get longer, if
+necessary, when they have formulas above and/or below them). We
+store the minimum length for individual arrows in math mode in
+\minaw@, and the minimum length for arrows in a commutative diagram
+in \minCDaw@.
+
+\minaw@ is made 11.11128\ex@ (i.e., 11.11128pt). I can't remember
+where I got this from! Probably the dimension of some symbol.
+\minCDaw is made 2.5pc.
+
+
+\minCDarrowwidth allows user to change the minimum length, provided
+we are in a displayed formula.
+
+
+\CD and \endCD are similar to \matrix and \endmatrix. Of course,
+there are no category code changes, nor any extra space (and so no
+\null), and we make the baselineskip bigger. But we also want to
+\let\ampersand@=&, so that the arrow macros will produce the &'s. As
+with \Let@, we have to hide this within \iffalse{\fi...\iffalse}\fi.
+We also set a flag, \ifCD@, to tell the arrow macros they are in a
+\CD (and hence should have longer length).
+
+
+\endCD just supplies the necessary \cr and }'s.
+
+
+\newdimen\bigaw@
+----------------
+Now we are ready for the arrows themselves. We store the actual
+length that an arrow will be in \bigaw@. Since the arrows are of the
+form @>>>, etc., we use \atdef@ to define them.
+
+
+@>#1>#2>#3>
+-----------
+
+%1 Arrow starts with & in a \CD.
+
+%2 \box0 has formula above the arrow, with suitable spacing around
+ it (\;\; at end to clear arrow head).
+
+%3 \box1 has formula below the arrow, with suitable spacing.
+
+%4 \box2 is just the part below, because we will do things
+ differently if there is no formula below.
+
+%5 If we are in a \CD, \bigaw@ is initially \minCDaw@, otherwise
+ \minaw@.
+
+%6 If formula above or below the arrow is bigger than \bigaw@,
+ change \bigaw@ to the maximum of these widths.
+
+%7 Extra space goes before the arrow in a \CD.
+
+%8 If there is something to go below the arrow, make an arrow of the
+ right length, with \rightarrowfill, make it a \mathop, so we can
+ use \limits to put the formulas above and below (the positioning
+ this provides isn't ideal, so it would probably be better to use
+ a more explicit construction here), and then make the resulting
+ arrow a \mathrel.
+
+%9 If nothing goes below, don't bother with the lower limit (so that
+ unnecessary space below isn't produced).
+
+%10 Extra space goes after the arrow in a \CD.
+
+%11 Arrow ends with & in a \CD.
+
+
+@<#1<#2<#3< is exactly analogous.
+
+
+@)#1)#2)#3), @(#1(#2(#3( are for foreign keyboards that don't have
+< and > available (because they are used for { and }, which are
+instead \AA and \aa).
+
+
+@A#1A#2A, @V#1V#2V
+------------------
+Vertical arrows don't need to bother with \ampersand@, since they are
+only used in \CD's. Notice that the space after \atdef@ is necessary,
+although space after @ in @A... and @V... won't be necessary later!
+
+
+@= is special, and used only in a \CD.
+
+
+@| is also used only in a \CD.
+
+
+\atdef@@\vert
+-------------
+We have to allow @\vert as a synonym, but this needs \atdef@@ instead.
+
+
+\pretend...\haswidth... is just a lot of syntax for a simple
+construction.
+
+
+\pmb is basically as in TB, p. 386, except that in math mode we use
+\mathpalette\pmb@, so that the symbol will change size. In addition,
+we want \pmb to keep binary relations and operators of the same type.
+We already have \binrel@, to start testing if something is of one of
+these two types, and we define \binrel@@ to complete things by making
+a \mathbin or \mathrel of the result.
+
+The final detail involves the amount to move the three copies that we
+are going to superimpose on each other. We want to use mu's rather
+than points or ems. Since 1em=18mu, we have .025em= .45mu, so we use
+-.45mu instead of .025em, and -.9mu instead of .05em. And since
+.0544em =.7794mu, we set a box with this width, and raise by that
+width (we store the width in the dimen register \pmbraise@ to be sure
+that \box4 doesn't happen to get used somewhere in between).
+
+We use \box3 in the definition of \pmb@ because \binrel@, used later,
+involves \box0 and \box1.
+
+
+\documentstyle is similar to LaTeX.
+
+
+\font\dummyft@ ...
+------------------
+For syntax checking, we need the dummy font (TB, p. 401). Since the
+dummy.tfm's available don't seem to have all the \fontdimen's they
+need, we explicitly set them right.
+
+
+\def\fontlist@
+--------------
+We need a list of all the fonts that are used, in the form of TB,
+p. 378, so that we can set them all to \dummyft@. First we list all
+the fonts already used.
+
+
+\font@ is to be used instead of \font, so that when new fonts are
+loaded in they will be added to the list.
+
+
+At this point we can add
+
+ \loadmsam
+ \loadmsbm
+ \loadeufm
+
+
+\dodummy@ sets all fonts to \dummyft@
+
+
+\def\nopages@
+-------------
+We will want to say \newtoks\output (TB, p. 401) within this control
+sequence. Since \newtoks is \outer, we will simply use the code
+instead.
+
+
+\ifsyntax@ is used to record the fact that \syntax was used. This
+might be needed by AMSPPT.STY.
+
+
+\newcount\countxviii@, \def\syntax
+----------------------------------
+To get syntax checking we also have to set \textfont0=\dummyft@, etc.
+We have to do this for all families, and the number of families is
+stored in \count18. The counter \countxviii@ is used to start with
+this value, and decrease in a \loop.
+
+%1 For syntax checking, we set \syntax@true, for use by AMSPPT.STY,
+ set all fonts to \dummyft@, with \dodummy@, set all \textfont's,
+ etc., to \dummyft@, using the \loop construction, and then do
+ everything else.
+
+
+\S@, \G@ and \P@ are used to check if S, G or P (or lowercase
+versions) were typed at the keyboard.
+
+
+\printoptions is a \loop that keeps insisting on an answer until S or
+s or G or g or P or p was typed at the keyboard. S chooses \syntax,
+G chooses \galleys, P just processes things as usual.
+
+%1 This converts the answer to uppercase (TB, p. 331).
+
+
+\def\alloc@
+-----------
+We now change \alloc@, since there are no further allocations in the
+file (or in AMSPPT.STY) that might have to be kept out of the log
+file. The new definition will write things in the log file only if
+\showallocations is used, so that \ifalloc@ is true.
+
+
+\document doesn't really do much in AmS-TeX---it was just put in to
+correspond to LaTeX. But at this point we might as well clear out
+\alloclist@ and \fontlist@, since anything in them will have been
+acted on by now.
+
+
+\enddocument, similarly, is just \bye, though AMSPPT.STY will make it
+considerably more complicated.
+
+
+\plainproclaim, \plainfootnote store plain's \proclaim and \footnote,
+which have different syntax from \proclaim and \footnote in
+AMSPPT.STY.
+
+
+\proclaim and \footnote themselves are made undefined, until a style
+file, like AMSPPT.STY, defines them.
+
+
+\= is also made undefined, since \B has been provided, and goes
+better with \b [to correspond to \D and \d, where \d had to be added
+since \. was redefined].
+
+
+\cal, \mit and \oldstyle are made undefined also, since this method
+of changing fonts is not used in AmS-TeX.
+
+
+The last thing is to make @ active.
+
+
+**********************************************************************
+
+HERE IS A SUMMARY OF ALL PLACES WHERE SPECIFIC VALUES USED IN THIS FILE
+ MIGHT NEED TO BE REPLACED, BECAUSE OF DIFFERENT FONTS, STYLES, ETC.
+
+ \sdrd@, \drsr@, \sldl@, \dlsl@
+ \captionwidth@
+ \ex@
+ spacing for \:
+ \initic@, \negintic@, and possibly \intkern@
+ spacing for \varinjlim, \varprojlim, \varliminf
+ \baselineskip and \lineskip for \smallmatrix
+ possibly \dotsspace@
+ format for \cases
+ \strutbox@
+ \tagform@
+ value of \interdisplaylinepenalty set by \allowdisplaybreaks
+ \multlinegap@
+ \multlinetaggap@ (and perhaps rule for setting tag separately on a
+ \multline)
+ spacing for \bmod, \pmod, \pod, \mod
+ \kern's for \overrightarrow, etc.
+ \dotso, \dotsb, \dotsm, \dotsc
+ spacing in \dddot, etc.
+ \mathsurround within the definition of \text@@ (\text outside of math),
+ in case it is set to a non-zero value in general.
+ \textdef@@
+ \scriptfont\itfam, etc.
+ \minaw@ and \minCDaw@
+ \baselineskip, \lineskip, and \lineskiplimit in \CD
+ the positioning of labels above and below arrows
+ the size of the symbols given by @= and @|
+ activation of \loadmsam, etc.
+
+**********************************************************************