From 72c9345e5bafe708888bf65448a81d1aee8275ed Mon Sep 17 00:00:00 2001
From: Norbert Preining <norbert@preining.info>
Date: Sat, 5 Oct 2019 03:01:15 +0000
Subject: CTAN sync 201910050301

---
 macros/latex/base/clsguide.tex | 1874 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1874 insertions(+)
 create mode 100644 macros/latex/base/clsguide.tex

(limited to 'macros/latex/base/clsguide.tex')

diff --git a/macros/latex/base/clsguide.tex b/macros/latex/base/clsguide.tex
new file mode 100644
index 0000000000..2b3c4b3b00
--- /dev/null
+++ b/macros/latex/base/clsguide.tex
@@ -0,0 +1,1874 @@
+% \iffalse meta-comment
+%
+% Copyright (C) 1993-2019
+% The LaTeX3 Project and any individual authors listed elsewhere
+% in this file. 
+% 
+% This file is part of the LaTeX base system.
+% -------------------------------------------
+% 
+% It may be distributed and/or modified under the
+% conditions of the LaTeX Project Public License, either version 1.3c
+% of this license or (at your option) any later version.
+% The latest version of this license is in
+%    http://www.latex-project.org/lppl.txt
+% and version 1.3c or later is part of all distributions of LaTeX 
+% version 2008 or later.
+% 
+% This file has the LPPL maintenance status "maintained".
+% 
+% The list of all files belonging to the LaTeX base distribution is
+% given in the file `manifest.txt'. See also `legal.txt' for additional
+% information.
+% 
+% The list of derived (unpacked) files belonging to the distribution 
+% and covered by LPPL is defined by the unpacking scripts (with 
+% extension .ins) which are part of the distribution.
+% 
+% \fi
+% Filename: clsguide.tex
+
+\NeedsTeXFormat{LaTeX2e}[1995/12/01]
+
+\documentclass{ltxguide}[1995/11/28]
+
+\title{\LaTeXe~for class and package writers}
+
+\author{Copyright \copyright~1995--2006 The \LaTeX3 Project\\
+   All rights reserved}
+
+\date{15 February 2006} 
+
+\begin{document}
+ 
+\maketitle
+ 
+\tableofcontents
+ 
+\section{Introduction}
+
+This document is an introduction to writing classes and packages for
+\LaTeX{}, with special attention given to upgrading existing
+\LaTeX~2.09 packages to \LaTeXe{}.  The latter subject is also
+covered in an article by Johannes Braams published in TUGboat~15.3.
+ 
+\subsection{Writing classes and packages for \LaTeXe}
+ 
+\LaTeX{} is a document preparation system that enables the document
+writer to concentrate on the contents of their text, without bothering
+too much about the formatting of it.  For example, chapters are
+indicated by |\chapter{<title>}| rather than by selecting 18pt bold.
+ 
+The file that contains the information about how to turn logical
+structure (like `|\chapter|') into formatting (like `18pt bold ragged
+right') is a \emph{document class}.  In addition, some features (such
+as colour or included graphics) are independent of the document class
+and these are contained in \emph{packages}.
+ 
+One of the largest differences between \LaTeX~2.09 and \LaTeXe{} is in
+the commands used to write packages and classes.  In \LaTeX~2.09,
+there was very little support for writing |.sty| files, and so writers
+had to resort to using low-level commands.
+ 
+\LaTeXe{} provides high-level commands for structuring packages.
+It is also much easier to build classes and packages on top of each
+other, for example writing a local technical report class |cetechr|
+(for the Chemical Engineering department) based on |article|.
+ 
+\subsection{Overview}
+ 
+This document contains an overview of how to write classes and
+packages for \LaTeX{}.  It does \emph{not} introduce all of the
+commands necessary to write packages: these can be found in either
+\emph{\LaTeXbook} or \emph{\LaTeXcomp}.  But it does describe the new
+commands for structuring classes and packages.
+
+\begin{description}
+ 
+\item[Section~\ref{Sec:general}] contains some general advice about
+  writing classes and packages.  It describes the difference between
+  classes and packages, the command naming conventions, the use of
+  |doc| and |docstrip|, how \TeX's primitive file and box commands
+  interact with \LaTeX{}. It also contains some hints about general
+  \LaTeX{} style.
+ 
+\item[Section~\ref{Sec:structure}] describes the structure of classes
+  and packages.  This includes building classes and packages on top of
+  other classes and packages, declaring options and declaring
+  commands.  It also contains example classes.
+ 
+\item[Section~\ref{Sec:commands}] lists the new class and package
+   commands.
+ 
+ \item[Section~\ref{Sec:upgrade}] gives detailed advice on how to
+   upgrade existing \LaTeX~2.09 classes and packages to \LaTeXe{}.
+ 
+\end{description}
+ 
+\subsection{Further information}
+ 
+For a general introduction to \LaTeX{}, including the new features of
+\LaTeXe{}, you should read \emph{\LaTeXbook}
+by Leslie Lamport~\cite{A-W:LLa94}.
+ 
+A more detailed description of the new features of \LaTeX, including an
+overview of more than 200 packages and nearly 1000 ready to run examples, is
+to be found in \emph{\LaTeXcomp\ second edition} by Frank Mittelbach and
+Michel Goossens~\cite{A-W:MG2004}.
+
+The \LaTeX{} system is based on \TeX{}, which is
+described in \emph{The \TeX book} by Donald E.~Knuth~\cite{A-W:DEK91}.
+ 
+There are a number of documentation files which accompany every copy
+of \LaTeX{}.  A copy of \emph{\LaTeX{} News} will come out with each
+six-monthly release of \LaTeX{}, and is found in the files
+|ltnews*.tex|.  The author's guide \emph{\usrguide} describes the new
+\LaTeX{} document features; it is in |usrguide.tex|.  The guide
+\emph{\fntguide} describes the \LaTeX{} font selection scheme for
+class- and package-writers; it is in |fntguide.tex|. Configuring
+\LaTeX{} is covered by the guide \emph{\cfgguide} in
+\texttt{cfgguide.tex} whilst the philosophy behind our policy on 
+modifying \LaTeX{} is described in \emph{\modguide} in
+\texttt{modguide.tex}.
+
+The documented source code (from the files used to produce the kernel
+format via |latex.ltx|) is now available as
+\emph{The \LaTeXe\ Sources}.
+This very large document also includes an index of
+\LaTeX{} commands.  It can be typeset from the \LaTeX{} file
+|source2e.tex| in the |base| directory, using the source files and
+the class file |ltxdoc.cls| from this directory.
+
+For more information about \TeX{} and \LaTeX{}, please contact your
+local \TeX{} Users Group, or the international \TeX{} Users Group.
+Addresses and other details can be found at:
+\begin{quote}\small\label{addrs}
+    \texttt{http://www.tug.org/lugs.html}
+\end{quote}
+
+
+\subsection{Policy on standard classes}
+
+Many of the problem reports we receive concerning the standard classes
+are not concerned with bugs but are suggesting, more or less politely,
+that the design decisions embodied in them are `not optimal' and
+asking us to modify them.
+
+There are several reasons why we should not make such changes to these
+files.
+\begin{itemize}
+\item
+  However misguided, the current behaviour is clearly what was
+  intended when these classes were designed.
+\item
+  It is not good practice to change such aspects of `standard classes'
+  because many people will be relying on them.
+\end{itemize}
+
+We have therefore decided not to even consider making such
+modifications, nor to spend time justifying that decision.  This does
+not mean that we do not agree that there are many deficiencies in the
+design of these classes, but we have many tasks with higher priority
+than continually explaining why the standard classes for \LaTeX{}
+cannot be changed.
+
+We would, of course, welcome the production of better classes, or of
+packages that can be used to enhance these classes.  So your first
+thought when you consider such a deficiency will, we hope, be ``what
+can I do to improve this?''  
+
+Similar considerations apply to those parts of the kernel that are
+implementing design decisions, many of which should be left to the
+class file but are not in the current system.  We realise that in such
+cases it is much more difficult for you to rectify the problem
+yourself but it is also the case that making such changes in the
+kernel would probably be a major project for us; therefore such
+enhancements will have to wait for \LaTeX3.
+
+\section{Writing classes and packages}
+\label{Sec:writing}
+ 
+This section covers some general points concerned with writing
+\LaTeX{} classes and packages.
+
+
+\subsection{Old versions}
+
+If you are upgrading an existing \LaTeX~2.09 style file then we
+recommend freezing the 2.09 version and no longer maintaining it.
+Experience with the various dialects of \LaTeX{} which existed in the
+early 1990's suggests that maintaining packages for different versions
+of \LaTeX{} is almost impossible.  It will, of course, be necessary
+for some organisations to maintain both versions in parallel for some
+time but this is not essential for those packages and classes
+supported by individuals: they should support only the new standard
+\LaTeXe{}, not obsolete versions of \LaTeX{}.
+
+
+\subsection{Using `docstrip' and `doc'}
+ 
+If you are going to write a large class or package for \LaTeX{} then
+you should consider using the |doc| software which comes with
+\LaTeX{}. 
+\LaTeX{} classes and packages written using this can be
+processed in two ways: they can be run through \LaTeX{}, to produce
+documentation; and they can be processed with |docstrip|, to produce
+the |.cls| or |.sty| file.
+ 
+The |doc| software can automatically generate indexes of definitions,
+indexes of command use, and change-log lists.  It is very useful for
+maintaining and documenting large \TeX{} sources.
+ 
+The documented sources of the \LaTeX{} kernel itself, and of the
+standard classes, etc, are |doc| documents; they are in the |.dtx|
+files in the distribution.  You can, in fact, typeset the source code
+of the kernel as one long document, complete with index, by running
+\LaTeX{} on |source2e.tex|.  Typesetting these documents uses the
+class file |ltxdoc.cls|.
+ 
+For more information on |doc| and |docstrip|, consult the files
+|docstrip.dtx|, |doc.dtx|, and \emph{\LaTeXcomp}.  For examples of its
+use, look at the |.dtx| files.
+
+\subsection{Is it a class or a package?}
+\label{Sec:classorpkg}
+ 
+The first thing to do when you want to put some new \LaTeX{} commands
+in a file is to decide whether it should be a \emph{document class} or a
+\emph{package}.  The rule of thumb is:
+\begin{quote}
+  If the commands could be used with any document class, then make
+  them a package; and if not, then make them a class.
+\end{quote}
+
+There are two major types of class: those like |article|, |report| or
+|letter|, which are free-standing; and those which are extensions or
+variations of other classes---for example, the |proc| document class,
+which is built on the |article| document class.
+
+Thus, a company might have a local |ownlet| class for printing letters
+with their own headed note-paper.  Such a class would build on top of
+the existing |letter| class but it cannot be used with any other
+document class, so we have |ownlet.cls| rather than |ownlet.sty|.
+ 
+The |graphics| package, in contrast, provides commands for including
+images into a \LaTeX{} document.  Since these commands can be used
+with any document class, we have |graphics.sty| rather than
+|graphics.cls|.
+ 
+
+\subsection{Command names}
+ 
+\LaTeX{} has three types of command.
+ 
+There are the author commands, such as |\section|, |\emph| and
+|\times|:  most of these have short names, all in lower case.
+ 
+There are also the class and package writer commands:
+most of these have long mixed-case names such as the following.
+\begin{verbatim}
+   \InputIfFileExists  \RequirePackage  \PassOptionsToClass
+\end{verbatim}
+ 
+Finally, there are the internal commands used in the \LaTeX{}
+implementation, such as |\@tempcnta|, |\@ifnextchar| and |\@eha|:
+most of these commands contain |@| in their name, which means they
+cannot be used in documents, only in class and package files.
+ 
+Unfortunately, for historical reasons the distinction between these
+commands is often blurred.  For example, |\hbox| is an internal
+command which should only be used in the \LaTeX{} kernel, whereas
+|\m@ne| is the constant $-1$ and could have been |\MinusOne|.
+ 
+However, this rule of thumb is still useful: if a command has |@| in
+its name then it is not part of the supported \LaTeX{} language---and
+its behaviour may change in future releases!  If a command is
+mixed-case, or is described in \emph{\LaTeXbook}, then you can rely on
+future releases of \LaTeXe{} supporting the command.
+ 
+\subsection{Box commands and colour}
+\label{Sec:colour}
+ 
+Even if you do not intend to use colour in your own documents, by
+taking note of the points in this section you can ensure that your
+class or package is compatible with the |color| package. This may
+benefit people using your class or package who have access to colour
+printers.
+ 
+The simplest way to ensure `colour safety' is to always use \LaTeX{}
+box commands rather than \TeX{} primitives, that is use |\sbox| rather
+than |\setbox|, |\mbox| rather than |\hbox| and |\parbox| or
+the |minipage| environment rather than |\vbox|.
+The \LaTeX{} box commands have new options which mean that they are now
+as powerful as the \TeX{} primitives.
+ 
+As an example of what can go wrong, consider that in 
+|{\ttfamily <text>}|
+the font is restored just \emph{before} the |}|, whereas in the
+similar looking construction
+|{\color{green} <text>}|
+the colour is restored just \emph{after} the final |}|. Normally this
+distinction does not matter at all; but consider a primitive \TeX{}
+box assignment such as:
+\begin{verbatim}
+   \setbox0=\hbox{\color{green} <text>}
+\end{verbatim}
+Now the colour-restore occurs after the |}| and so is \emph{not}
+stored in the box. Exactly what bad effects this can have depends on
+how colour is implemented: it can range from getting the wrong
+colours in the rest of the document, to causing errors in the
+dvi-driver used to print the document.
+ 
+Also of interest is the command |\normalcolor|.   This is 
+normally just |\relax| (i.e., does nothing)
+but you can use it rather like |\normalfont| to 
+set regions of the page such as captions or section headings to the 
+`main document colour'.
+
+
+\subsection{Defining text and math characters}
+\label{Sec:chars}
+
+Because \LaTeXe{} supports different encodings, definitions of commands
+for producing symbols, accents, composite glyphs, etc.\ must be
+defined using the commands provided for this purpose and described in
+\emph{\fntguide}.  This part of the system is still under development
+so such tasks should be undertaken with great caution.
+
+Also, |\DeclareRobustCommand| should be used for encoding-independent
+commands of this type.
+
+Note that it is no longer possible to refer to the math font set-up
+outside math mode: for example, neither |\textfont 1| nor
+|\scriptfont 2| are guaranteed to be defined in other modes.
+
+
+\subsection{General style}
+\label{Sec:general}
+
+The new system provides many commands designed to help you produce
+well-structured class and package files that are both robust and
+portable.  This section outlines some ways to make intelligent use of
+these. 
+
+\subsubsection{Loading other files}
+\label{Sec:loading}
+
+\NEWdescription{1995/12/01}
+\LaTeX{} provides these commands: 
+\begin{verbatim}
+   \LoadClass        \LoadClassWithOptions
+   \RequirePackage   \RequirePackageWithOptions
+\end{verbatim}
+for using classes or packages inside other classes or packages.  We
+recommend strongly that you use them, rather than the primitive
+|\input| command, for a number of reasons.
+ 
+Files loaded with |\input <filename>| will not be listed in the
+|\listfiles| list.
+ 
+If a package is always loaded with |\RequirePackage...| or |\usepackage|
+then, even if its loading is requested several times, it will be
+loaded only once.  By contrast, if it is loaded with |\input| then it
+can be loaded more than once; such an extra loading may waste time and
+memory and it may produce strange results.
+ 
+If a package provides option-processing then, again, strange results
+are possible if the package is |\input| rather than loaded by means of
+|\usepackage| or |\RequirePackage...|.
+ 
+If the package |foo.sty| loads the package |baz.sty| by use of
+|\input baz.sty| then the user will get a warning:
+\begin{verbatim}
+   LaTeX Warning: You have requested package `foo',
+                  but the package provides `baz'.
+\end{verbatim}
+Thus, for several reasons, using |\input| to load packages is not a
+good idea.
+ 
+Unfortunately, if you are upgrading the file |myclass.sty| to a class
+file then you have to make sure that any old files which contain
+|\input myclass.sty| still work.
+
+This was also true for the standard classes (|article|, |book| and
+|report|), since a lot of existing \LaTeX~2.09 document styles contain
+|\input article.sty|.  The approach which we use to solve this is
+to provide minimal files |article.sty|, |book.sty| and |report.sty|,
+which simply load the appropriate class files.
+
+For example, |article.sty| contains just the following lines:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \@obsoletefile{article.cls}{article.sty}
+   \LoadClass{article}
+\end{verbatim}
+You may wish to do the same or, if you think that it is safe to do so,
+you may decide to just remove |myclass.sty|.
+ 
+\subsubsection{Make it robust}
+
+We consider it good practice, when writing packages and classes, to use
+\LaTeX{} commands as much as possible.
+
+Thus, instead of using |\def...| we recommend using one of
+|\newcommand|, |\renewcommand| or |\providecommand|; |\CheckCommand| is
+also useful. Doing this makes
+it less likely that you will inadvertently redefine a command, giving
+unexpected results.
+ 
+When you define an environment, use |\newenvironment| or
+|\renewenvironment| instead |\def\foo{...}| and |\def\endfoo{...}|.
+ 
+If you need to set or change the value of a \m{dimen} or \m{skip}
+register, use |\setlength|.
+ 
+To manipulate boxes, use \LaTeX{} commands such as |\sbox|,
+|\mbox| and |\parbox| rather than |\setbox|, |\hbox| and |\vbox|.
+ 
+Use |\PackageError|, |\PackageWarning| or |\PackageInfo| (or the
+equivalent class commands) rather than |\@latexerr|, |\@warning| or
+|\wlog|.
+ 
+It is still possible to declare options by defining |\ds@<option>| and
+calling |\@options|; but we recommend the |\DeclareOption| and
+|\ProcessOptions| commands instead.  These are more powerful and use
+less memory.  So rather than using:
+\begin{verbatim}
+   \def\ds@draft{\overfullrule 5pt}
+   \@options
+\end{verbatim}
+you should use:
+\begin{verbatim}
+   \DeclareOption{draft}{\setlength{\overfullrule}{5pt}}
+   \ProcessOptions\relax
+\end{verbatim}
+
+The advantage of this kind of practice is that your code is more
+readable and, more important, that it is less likely to break when
+used with future versions of \LaTeX{}.
+
+\subsubsection{Make it portable}
+
+It is also sensible to make your files are as portable as possible. To
+ensure this; they should contain only visible 7-bit text; and the
+filenames should contain at most eight characters (plus the three
+letter extension).  Also, of course, it \textbf{must not} have the
+same name as a file in the standard \LaTeX{} distribution, however
+similar its contents may be to one of these files.
+
+It is also useful if local classes or packages have a common prefix,
+for example the University of Nowhere classes might begin with |unw|.
+This helps to avoid every University having its own thesis class, all
+called |thesis.cls|.
+ 
+If you rely on some features of the \LaTeX{} kernel, or on a package,
+please specify the release-date you need.  For example, the package
+error commands were introduced in the June 1994 release so, if you use
+them then you should put:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}[1994/06/01]
+\end{verbatim}
+
+\subsubsection{Useful hooks}
+
+Some packages and document styles had to redefine the command
+|\document| or |\enddocument| to achieve their goal.  This is no
+longer necessary. You can now use the `hooks' |\AtBeginDocument| and
+|\AtEndDocument| (see Section~\ref{Sec:delays}).  Again, using these
+hooks makes it less likely that your code breaks with future versions
+of \LaTeX{}. It also makes it more likely that your package can work
+together with someone else's.
+
+\NEWdescription{1996/12/01}
+However, note that code in the |\AtBeginDocument| hook is part of the
+preamble.  Thus there are restrictions on what can be put there; in
+particular, no typesetting can be done.
+
+\section{The structure of a class or package}
+\label{Sec:structure}
+ 
+\LaTeXe{} classes and packages have more structure than \LaTeX~2.09
+style files did.  The outline of a class or package file is:
+\begin{description}
+\item[Identification] The file says that it is a \LaTeXe{} package or
+   class, and gives a short description of itself.
+\item[Preliminary declarations]
+   Here the file declares some commands and can also load
+   other files.  Usually these commands will be just those needed for
+   the code used in the declared options.
+\item[Options] The file declares and processes its options.
+\item[More declarations] This is where the file does most of its work:
+   declaring new variables, commands and fonts; and loading other files.
+\end{description}
+ 
+\subsection{Identification}
+ 
+The first thing a class or package file does is identify itself.
+Package files do this as follows:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \ProvidesPackage{<package>}[<date> <other information>]
+\end{verbatim}
+For example:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \ProvidesPackage{latexsym}[1994/06/01 Standard LaTeX package]
+\end{verbatim}
+Class files do this as follows:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \ProvidesClass{<class-name>}[<date> <other information>]
+\end{verbatim}
+For example:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \ProvidesClass{article}[1994/06/01 Standard LaTeX class]
+\end{verbatim}
+\NEWdescription{1998/06/19}
+The \m{date} should be given in the form `\textsc{yyyy/mm/dd}' and
+must be present if the optional argument is used (this is also true
+for the |\NeedsTeXFormat| command). 
+Any derivation from this syntax will result in low-level \TeX{}
+errors---the commands expect a valid syntax to speed up the daily
+usage of the package or class and make no provision for the case that
+the developer made a mistake!
+
+This date is checked whenever a user specifies a date in their
+|\documentclass| or |\usepackage| command.  For example, if you wrote:
+\begin{verbatim}
+   \documentclass{article}[1995/12/23]
+\end{verbatim}
+then users at a different location 
+would get a warning that their copy of |article| was out of
+date.
+ 
+The description of a class is displayed when the class is used.  The
+description of a package is put into the log file.  These descriptions
+are also displayed by the |\listfiles| command.  The phrase
+\texttt{Standard LaTeX} \textbf{must not} be used in the identification
+banner of any file other than those in the standard \LaTeX{}
+distribution.
+
+ 
+\subsection{Using classes and packages}
+ 
+The first major difference between \LaTeX~2.09 style files and
+\LaTeXe{} packages and classes is that \LaTeXe{} supports
+\emph{modularity}, in the sense of building files from small
+building-blocks rather than using large single files.
+ 
+A \LaTeX{} package or class can load a package as follows:
+\begin{verbatim}
+   \RequirePackage[<options>]{<package>}[<date>]
+\end{verbatim}
+For example:
+\begin{verbatim}
+   \RequirePackage{ifthen}[1994/06/01]
+\end{verbatim}
+This command has the same syntax as the author command |\usepackage|.
+It allows packages or classes to use features provided by other
+packages.  For example, by loading the |ifthen| package, a package
+writer can use the `if\dots then\dots else\dots' commands provided
+by that package.
+ 
+A \LaTeX{} class can load one other class as follows:
+\begin{verbatim}
+   \LoadClass[<options>]{<class-name>}[<date>]
+\end{verbatim}
+For example:
+\begin{verbatim}
+   \LoadClass[twocolumn]{article}
+\end{verbatim}
+This command has the same syntax as the author command |\documentclass|.
+It allows classes to be based on the syntax and appearance of another
+class.  For example, by loading the |article| class, a class writer
+only has to change the bits of |article| they don't like, rather than
+writing a new class from scratch.
+
+\NEWfeature{1995/12/01}
+The following commands can be used in the common case that you want to
+simply load a class or package file with exactly those options that
+are being used by the current class.
+\begin{verbatim}
+   \LoadClassWithOptions{<class-name>}[<date>]
+   \RequirePackageWithOptions{<package>}[<date>]
+\end{verbatim}
+For example:
+\begin{verbatim}
+   \LoadClassWithOptions{article}
+   \RequirePackageWithOptions{graphics}[1995/12/01]
+\end{verbatim}
+
+\subsection{Declaring options}
+ 
+\NEWdescription{1998/12/01}
+The other major difference between \LaTeX~2.09 styles and \LaTeXe{}
+packages and classes is in option handling.  Packages and classes can
+now declare options and these can be specified by authors; for
+example, the |twocolumn| option is declared by the |article| class.
+Note that the name of an option should contain only those characters
+allowed in a `\LaTeX{} name'; in particular it must not contain any
+control sequences.
+
+An option is declared as follows:
+\begin{verbatim}
+   \DeclareOption{<option>}{<code>}
+\end{verbatim}
+For example, the |dvips| option (slightly simplified)
+to the |graphics| package is implemented as:
+\begin{verbatim}
+   \DeclareOption{dvips}{\input{dvips.def}}
+\end{verbatim}
+This means that when an author writes |\usepackage[dvips]{graphics}|,
+the file |dvips.def| is loaded.  As another example, the |a4paper|
+option is declared in the |article| class to set the |\paperheight|
+and |\paperwidth| lengths:
+\begin{verbatim}
+   \DeclareOption{a4paper}{%
+      \setlength{\paperheight}{297mm}%
+      \setlength{\paperwidth}{210mm}%
+   }
+\end{verbatim}
+Sometimes a user will request an option which the class
+or package has not explicitly declared.  By default this will produce
+a warning (for classes) or error (for packages); this behaviour
+can be altered as follows:
+\begin{verbatim}
+   \DeclareOption*{<code>}
+\end{verbatim}
+For example, to make the package |fred| produce a warning rather than
+an error for unknown options, you could specify:
+\begin{verbatim}
+   \DeclareOption*{%
+      \PackageWarning{fred}{Unknown option `\CurrentOption'}%
+   }
+\end{verbatim}
+Then, if an author writes |\usepackage[foo]{fred}|, they will get a
+warning \texttt{Package fred Warning: Unknown option `foo'.}  As
+another example, the |fontenc| package tries to load a file
+|<ENC>enc.def| whenever the \m{ENC} option is used.  This
+can be done by writing:
+\begin{verbatim}
+   \DeclareOption*{%
+      \input{\CurrentOption enc.def}%
+   }
+\end{verbatim}
+\NEWdescription{1998/12/01}
+It is possible to pass options on to another package or class, using
+the command |\PassOptionsToPackage| or |\PassOptionsToClass| (note
+that this is a specialised operation that works only for option
+names).  For example, to pass every unknown option on to the |article|
+class, you can use:
+\begin{verbatim}
+   \DeclareOption*{%
+      \PassOptionsToClass{\CurrentOption}{article}%
+   }
+\end{verbatim}
+If you do this then you should make sure you load the class at some
+later point, otherwise the options will never be processed!
+ 
+So far, we have explained only how to declare options, not how to
+execute them.  To process the options with which the file was called,
+you should use:
+\begin{verbatim}
+   \ProcessOptions\relax
+\end{verbatim}
+This executes the \m{code} for each option that was both specified and
+declared (see Section~\ref{Sec:commands.options} for details of how
+this is done).
+ 
+For example, if the |jane| package file contains:
+\begin{verbatim}
+   \DeclareOption{foo}{\typeout{Saw foo.}}
+   \DeclareOption{baz}{\typeout{Saw baz.}}
+   \DeclareOption*{\typeout{What's \CurrentOption?}}
+   \ProcessOptions\relax
+\end{verbatim}
+and an author writes |\usepackage[foo,bar]{jane}|, then they will see
+the messages \texttt{Saw foo.} and \texttt{What's bar?}
+ 
+\subsection{A minimal class file}
+ 
+Most of the work of a class or package is in defining new commands, or
+changing the appearance of documents.  This is done in the body of the
+package, using commands such as |\newcommand| or |\setlength|.
+
+\LaTeXe{} provides several new commands to help class and package
+writers; these are described in detail in Section~\ref{Sec:commands}.
+ 
+There are four things that every class file \emph{must} contain: these
+are a definition of |\normalsize|, values for |\textwidth| and
+|\textheight| and a specification for page-numbering.  So a minimal
+document class file\footnote {This class is now in the standard
+distribution, as \texttt{minimal.cls}.} looks like this:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \ProvidesClass{minimal}[1995/10/30 Standard LaTeX minimal class]
+   \renewcommand{\normalsize}{\fontsize{10pt}{12pt}\selectfont}
+   \setlength{\textwidth}{6.5in}
+   \setlength{\textheight}{8in}
+   \pagenumbering{arabic}       % needed even though this class will
+                                % not show page numbers
+\end{verbatim}
+However, this class file will not support footnotes, marginals,
+floats, etc., nor will it provide any of the 2-letter font commands
+such as |\rm|; thus most classes will contain more than this minimum!
+ 
+\subsection{Example: a local letter class}
+ 
+A company may have its own letter class, for setting letters in the
+company style.  This section shows a simple implementation of such a
+class, although a real class would need more structure.
+ 
+The class begins by announcing itself as |neplet.cls|.
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \ProvidesClass{neplet}[1995/04/01 NonExistent Press letter class]
+\end{verbatim}
+Then this next bit passes any options on to the |letter| class, which
+is loaded with the |a4paper| option.
+\begin{verbatim}
+   \DeclareOption*{\PassOptionsToClass{\CurrentOption}{letter}}
+   \ProcessOptions\relax
+   \LoadClass[a4paper]{letter}
+\end{verbatim}
+In order to use the company letter head, it redefines the
+|firstpage| page style: this is the page style that is used on
+the first page of letters.
+\begin{verbatim}
+   \renewcommand{\ps@firstpage}{%
+      \renewcommand{\@oddhead}{<letterhead goes here>}%
+      \renewcommand{\@oddfoot}{<letterfoot goes here>}%
+   }
+\end{verbatim}
+And that's it!
+ 
+\subsection{Example: a newsletter class}
+ 
+A simple newsletter can be typeset with \LaTeX{}, using a variant of the
+|article| class.
+The class begins by announcing itself as |smplnews.cls|.
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}
+   \ProvidesClass{smplnews}[1995/04/01 The Simple News newsletter class]
+
+   \newcommand{\headlinecolor}{\normalcolor}
+\end{verbatim}
+It passes most specified options on to the |article| class: apart from
+the |onecolumn| option, which is switched off, and the |green| option,
+which sets the headline in green.
+\begin{verbatim}
+   \DeclareOption{onecolumn}{\OptionNotUsed}
+   \DeclareOption{green}{\renewcommand{\headlinecolor}{\color{green}}}
+
+   \DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
+
+   \ProcessOptions\relax
+\end{verbatim}
+It then loads the class |article| with the option |twocolumn|.
+\begin{verbatim}
+   \LoadClass[twocolumn]{article}
+\end{verbatim}
+Since the newsletter is to be printed in colour, it now loads the
+|color| package.  The class does not specify a device driver option
+since this should be specified by the user of the |smplnews| class.
+\begin{verbatim}
+   \RequirePackage{color}
+\end{verbatim}
+The class then redefines |\maketitle| to produce the title in 72pt
+Helvetica bold oblique, in the appropriate colour.
+\begin{verbatim}
+   \renewcommand{\maketitle}{%
+      \twocolumn[%
+         \fontsize{72}{80}\fontfamily{phv}\fontseries{b}%
+         \fontshape{sl}\selectfont\headlinecolor
+         \@title
+      ]%
+   }
+\end{verbatim}
+It redefines |\section| and switches off section numbering.
+\begin{verbatim}
+   \renewcommand{\section}{%
+      \@startsection
+         {section}{1}{0pt}{-1.5ex plus -1ex minus -.2ex}%
+         {1ex plus .2ex}{\large\sffamily\slshape\headlinecolor}%
+   }
+ 
+   \setcounter{secnumdepth}{0}
+\end{verbatim}
+It also sets the three essential things.
+\begin{verbatim}
+   \renewcommand{\normalsize}{\fontsize{9}{10}\selectfont}
+   \setlength{\textwidth}{17.5cm}
+   \setlength{\textheight}{25cm}
+\end{verbatim}
+In practice, a class would need more than this: it would provide
+commands for issue numbers, authors of articles, page styles and so
+on; but this skeleton gives a start.  The |ltnews| class file is not
+much more complex than this one.
+ 
+\section{Commands for class and package writers}
+\label{Sec:commands}
+ 
+This section describes briefly each of the new commands for class and
+package writers.  To find out about other aspects of the new system,
+you should also read \emph{\LaTeXbook}, \emph{\LaTeXcomp} and
+\emph{\usrguide}.
+ 
+\subsection{Identification}
+ 
+The first group of commands discussed here are those used
+to identify your class or package file.
+ 
+\begin{decl}
+|\NeedsTeXFormat| \arg{format-name} \oarg{release-date}
+\end{decl}
+This command tells \TeX{} that this file should be processed using a
+format with name \m{format-name}.  You can use the optional argument
+\m{release-date} to further specify the earliest release date of the
+format that is needed.  When the release date of the format is older
+than the one specified a warning will be generated. The standard
+\m{format-name} is \texttt{LaTeX2e}.  The date, if present, must be in
+the form \textsc{yyyy/mm/dd}.
+ 
+Example:
+\begin{verbatim}
+   \NeedsTeXFormat{LaTeX2e}[1994/06/01]
+\end{verbatim}
+ 
+\begin{decl}
+|\ProvidesClass| \arg{class-name} \oarg{release-info} \\
+|\ProvidesPackage| \arg{package-name} \oarg{release-info}
+\end{decl}
+This declares that the current file contains the definitions for the
+document class \m{class-name} or package \m{package-name}.
+
+The optional \m{release-info}, if used, must contain:
+\begin{itemize}
+  \item the release date of
+  this version of the file, in the form \textsc{yyyy/mm/dd};
+\item optionally followed by a space and a short description, possibly
+  including a version number.
+\end{itemize}
+The above syntax must be followed exactly so that this information
+can be used by |\LoadClass| or |\documentclass| (for classes) or
+|\RequirePackage| or |\usepackage| (for packages) to test that the
+release is not too old.
+
+The whole of this \m{release-info} information is displayed by
+|\listfiles| and should therefore not be too long.
+ 
+Example:
+\begin{verbatim}
+   \ProvidesClass{article}[1994/06/01 v1.0 Standard LaTeX class]
+   \ProvidesPackage{ifthen}[1994/06/01 v1.0 Standard LaTeX package]
+\end{verbatim}
+ 
+\begin{decl}
+  |\ProvidesFile| \arg{file-name} \oarg{release-info}
+\end{decl}
+This is similar to the two previous commands except that here the full
+filename, including the extension, must be given. It is used for
+declaring any files other than main class and package files.
+ 
+Example:
+\begin{verbatim}
+   \ProvidesFile{T1enc.def}[1994/06/01 v1.0 Standard LaTeX file]
+\end{verbatim}
+ 
+Note that the phrase \texttt{Standard LaTeX} \textbf{must not} be used
+in the identification banner of any file other than those in the
+standard \LaTeX{} distribution.
+
+\subsection{Loading files}
+\label{Sec:loadf}
+
+\NEWfeature{1995/12/01}
+This group of commands can be used to create your own document class or
+package by building on existing classes or packages.
+\begin{decl}
+  |\RequirePackage| \oarg{options-list} \arg{package-name}
+     \oarg{release-info}\\
+  |\RequirePackageWithOptions| \arg{package-name}
+     \oarg{release-info}
+\end{decl}
+Packages and classes should use these commands to load other packages.
+
+The use of |\RequirePackage| is the same as the author command
+|\usepackage|.
+ 
+Examples:
+\begin{verbatim}
+   \RequirePackage{ifthen}[1994/06/01]
+   \RequirePackageWithOptions{graphics}[1995/12/01]
+\end{verbatim}
+ 
+\begin{decl}
+  |\LoadClass| \oarg{options-list} \arg{class-name}
+     \oarg{release-info}\\
+  |\LoadClassWithOptions| \arg{class-name}
+     \oarg{release-info}
+\end{decl}
+\NEWfeature{1995/12/01}
+These commands are for use \emph{only} in class files, they cannot be
+used in packages files;
+they can be used at most once within a class file.
+ 
+The use of |\LoadClass| is the same as
+the use of |\documentclass| to load a class file.
+
+Examples:
+\begin{verbatim}
+   \LoadClass{article}[1994/06/01]
+   \LoadClassWithOptions{article}[1995/12/01]
+\end{verbatim}
+
+\NEWfeature{1995/12/01}
+The two |WithOptions| versions simply load the class (or package) file
+with exactly those options that are being used by the current file
+(class or package).  See below, in \ref{Sec:opmove}, for further
+discussion of their use.
+
+
+\subsection{Option declaration}
+\label{Sec:commands.options.dec}
+
+\NEWdescription{1998/12/01}
+The following commands deal with the declaration and handling of
+options to document classes and packages.  Every option name must be a
+`\LaTeX{} name'.
+
+There are some commands designed especially for use within the
+\m{code} argument of these commands (see below).
+
+\begin{decl}
+  |\DeclareOption| \arg{option-name} \arg{code}
+\end{decl}
+This makes \m{option-name} a `declared option' of the class or package
+in which it is put.  
+
+The \m{code} argument contains the code to be executed if that option
+is specified for the class or package; it can contain any valid
+\LaTeXe{} construct.
+
+Example:
+\begin{verbatim}
+   \DeclareOption{twoside}{\@twosidetrue}
+\end{verbatim}
+ 
+\begin{decl}
+  |\DeclareOption*| \arg{code}
+\end{decl}
+This declares the \m{code} to be executed for every option which is
+specified for, but otherwise not explicitly declared by, the class or
+package; this code is called the `default option code' and it can
+contain any valid \LaTeXe{} construct.
+
+If a class file contains no |\DeclareOption*| then, by default, all
+specified but undeclared options for that class will be silently
+passed to all packages (as will the specified and declared options for
+that class).
+
+If a package file contains no |\DeclareOption*| then, by default, each
+specified but undeclared option for that package will produce an error.
+
+
+\subsection{Commands within option code}
+\label{Sec:within.code}
+
+These two commands can be used only within the \m{code} argument of
+either |\DeclareOption| or |\DeclareOption*|.  Other commands commonly
+used within these arguments can be found in the next few subsections.
+
+\begin{decl}
+  |\CurrentOption|
+\end{decl}
+This expands to the name of the current option.
+ 
+\begin{decl}
+  |\OptionNotUsed|
+\end{decl}
+This causes the current option to
+be added to the list of `unused options'.
+
+\NEWfeature{1995/06/01}
+  You can now include hash marks (\texttt{\#}) within these \m{code}
+  arguments without special treatment (formerly, it had been
+  necessary to double them).
+
+\subsection{Moving options around}
+\label{Sec:opmove} 
+
+These two commands are also very useful within the \m{code} argument
+of |\DeclareOption| or |\DeclareOption*|:
+\begin{decl}
+  |\PassOptionsToPackage| \arg{options-list} \arg{package-name}\\
+  |\PassOptionsToClass| \arg{options-list} \arg{class-name}
+\end{decl}
+The command |\PassOptionsToPackage| passes the option names in
+\m{options-list} to package \m{package-name}.
+This means that it adds the \m{option-list} to the
+list of options used by any future |\RequirePackage| or |\usepackage|
+command for package \m{package-name}.
+ 
+Example:
+\begin{verbatim}
+   \PassOptionsToPackage{foo,bar}{fred}
+   \RequirePackage[baz]{fred}
+\end{verbatim}
+is the same as:
+\begin{verbatim}
+   \RequirePackage[foo,bar,baz]{fred}
+\end{verbatim}
+
+Similarly, |\PassOptionsToClass| may be used in a class file to pass
+options to another class to be loaded with |\LoadClass|.
+ 
+\NEWdescription{1995/12/01}
+The effects and use of these two commands should be contrasted with
+those of the following two (documented above, in \ref{Sec:loadf}):
+\begin{verbatim}
+   \LoadClassWithOptions
+   \RequirePackageWithOptions
+\end{verbatim}
+The command |\RequirePackageWithOptions| is similar to
+|\RequirePackage|, but it always loads the required package with
+exactly the same option list as that being used by the current class
+or package, rather than with any option explicitly supplied or passed
+on by |\PassOptionsToPackage|.
+
+The main purpose of |\LoadClassWithOptions| is to allow one class to
+simply build on another, for example:
+\begin{verbatim}
+  \LoadClassWithOptions{article}
+\end{verbatim}
+This should be compared with the slightly different construction
+\begin{verbatim}
+  \DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
+  \ProcessOptions\relax
+  \LoadClass{article}
+\end{verbatim}
+As used above, the effects are more or less the same, but the first is
+a lot less to type; also the |\LoadClassWithOptions| method runs
+slightly quicker.
+
+If, however, the class declares options of its own then
+the two constructions are different.  Compare, for example:
+\begin{verbatim}
+  \DeclareOption{landscape}{\@landscapetrue}
+  \ProcessOptions\relax
+  \LoadClassWithOptions{article}
+\end{verbatim}
+with:
+\begin{verbatim}
+  \DeclareOption{landscape}{\@landscapetrue}
+  \DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
+  \ProcessOptions\relax
+  \LoadClass{article}
+\end{verbatim}
+In the first example, the \textsf{article} class will be loaded with
+option |landscape| precisely when the current class is called with
+this option. By contrast, in the second example it will never be
+called with option \texttt{landscape} as in that case \textsf{article}
+is passed options only by the default option handler, but this handler
+is not used for |landscape| because that option is explicitly
+declared.
+
+\subsection{Delaying code}
+\label{Sec:delays}
+
+These first two commands are also intended primarily for use within 
+the \m{code} argument of |\DeclareOption| or |\DeclareOption*|.
+
+\begin{decl}
+  |\AtEndOfClass| \arg{code}\\
+  |\AtEndOfPackage| \arg{code}
+\end{decl}
+These commands declare \m{code} that is saved away internally and then
+executed after processing the whole of the current class or package
+file.
+ 
+Repeated use of these commands is permitted: the code in the
+arguments is stored (and later executed) in the order of their
+declarations.
+ 
+\begin{decl}
+  |\AtBeginDocument| \arg{code}\\
+  |\AtEndDocument| \arg{code}
+\end{decl}
+These commands declare \m{code} to be saved internally and executed
+while \LaTeX{} is executing |\begin{document}| or |\end{document}|.
+ 
+The \m{code} specified in the argument to |\AtBeginDocument| is
+executed near the end of the |\begin{document}| code, \emph{after} the
+font selection tables have been set up.  It is therefore a useful
+place to put code which needs to be executed after everything has been
+prepared for typesetting and when the normal font for the document is
+the current font.
+
+\NEWdescription{1995/12/01}
+The |\AtBeginDocument| hook should not be used for code that does any
+typesetting since the typeset result would be unpredictable.
+
+The \m{code} specified in the argument to |\AtEndDocument| is
+executed at the beginning of the |\end{document}| code,
+\emph{before} the final page is finished and before any leftover
+floating environments are processed. If some of the \m{code} is to be
+executed after these two processes, you should include a |\clearpage|
+at the appropriate point in \m{code}.
+ 
+Repeated use of these commands is permitted: the code in the
+arguments is stored (and later executed) in the order of their
+declarations.
+ 
+\begin{decl}[1994/12/01]
+  |\AtBeginDvi| \arg{specials}
+\end{decl}
+These commands save in a box register things which are written to the
+|.dvi| file at the beginning of the `shipout' of the first page of the
+document.
+
+This should not be used for anything that will add any typeset
+material to the |.dvi| file.
+ 
+Repeated use of this command is permitted.
+ 
+
+\subsection{Option processing}
+\label{Sec:commands.options}
+ 
+\begin{decl}
+  |\ProcessOptions|
+\end{decl}
+This command executes the \m{code} for each selected option.
+ 
+We shall first describe how |\ProcessOptions| works in a package file,
+and then how this differs in a class file.
+ 
+To understand in detail what |\ProcessOptions| does in a package file,
+you have to know the difference between \emph{local} and \emph{global}
+options.
+\begin{itemize}
+\item \textbf{Local options} are those which have been explicitly
+  specified for this particular package in the \m{options} argument of
+  any of these:
+\begin{quote}
+    |\PassOptionsToPackage{<options>}| \ |\usepackage[<options>]|\\
+    |\RequirePackage[<options>]|
+\end{quote}
+\item \textbf{Global options} are any other options that are specified
+  by the author in the \m{options} argument of
+    |\documentclass[<options>]|.
+\end{itemize}
+For example, suppose that a document begins:
+\begin{verbatim}
+   \documentclass[german,twocolumn]{article}
+   \usepackage{gerhardt}
+\end{verbatim}
+whilst package |gerhardt| calls package |fred| with:
+\begin{verbatim}
+   \PassOptionsToPackage{german,dvips,a4paper}{fred}
+   \RequirePackage[errorshow]{fred}
+\end{verbatim}
+then:
+\begin{itemize}
+\item |fred|'s local options are |german|, |dvips|, |a4paper|
+  and |errorshow|;
+\item |fred|'s only global option is |twocolumn|.
+\end{itemize}
+
+When |\ProcessOptions| is called, the following happen.
+\begin{itemize}
+\item \emph{First}, for each option so far declared in |fred.sty|
+  by |\DeclareOption|, it looks to see if that option is either a
+  global or a local option for |fred|: if it is then the corresponding
+  code is executed.
+
+  This is done in the order in which these options
+  were declared in |fred.sty|.
+\item \emph{Then}, for each remaining \emph{local} option, the command
+  |\ds@<option>| is executed if it has been defined somewhere (other
+  than by a |\DeclareOption|); otherwise, the `default option code' is
+  executed.  If no default option code has been declared then an error
+  message is produced.
+
+  This is done in the order in which these
+  options were specified.
+\end{itemize}
+Throughout this process, the system ensures that the code declared for
+an option is executed at most once.
+
+Returning to the example, if |fred.sty| contains:
+\begin{verbatim}
+   \DeclareOption{dvips}{\typeout{DVIPS}}
+   \DeclareOption{german}{\typeout{GERMAN}}
+   \DeclareOption{french}{\typeout{FRENCH}}
+   \DeclareOption*{\PackageWarning{fred}{Unknown `\CurrentOption'}}
+   \ProcessOptions\relax
+\end{verbatim}
+then the result of processing this document will be:
+\begin{verbatim}
+   DVIPS
+   GERMAN
+   Package fred Warning: Unknown `a4paper'.
+   Package fred Warning: Unknown `errorshow'.
+\end{verbatim}
+Note the following:
+
+\begin{itemize}
+\item the code for the |dvips| option is executed before that for the
+  |german| option, because that is the order in which they are declared
+  in |fred.sty|;
+\item the code for the |german| option is executed only once, when the
+  declared options are being processed;
+\item the |a4paper| and |errorshow| options produce the warning from
+  the code declared by |\DeclareOption*| (in the order in which they
+  were specified), whilst the |twocolumn| option does not: this is
+  because |twocolumn| is a global option.
+\end{itemize}
+ 
+In a class file, |\ProcessOptions| works in the same way, except
+that: \emph{all} options are local; and the default value for
+|\DeclareOption*| is |\OptionNotUsed| rather than an error.
+
+\NEWdescription{1995/12/01}
+Note that, because |\ProcessOptions| has a |*|-form, it is wise to
+follow the non-star form with |\relax|, as in the previous examples,
+since this prevents unnecessary look ahead and possibly misleading
+error messages being issued.
+
+\begin{decl}
+  |\ProcessOptions*| \\
+  |\@options|
+\end{decl}
+This is like |\ProcessOptions| but it executes the options in the
+order specified in the calling commands, rather than in the order of
+declaration in the class or package. For a package this means that the
+global options are processed first. 
+
+The |\@options| command from \LaTeX~2.09 has been made equivalent to
+this in order to ease the task of updating old document styles to
+\LaTeXe{} class files.
+
+\begin{decl}
+  |\ExecuteOptions| \arg{options-list}
+\end{decl}
+
+For each option in the \m{options-list}, in order, 
+this command simply executes the command 
+|\ds@<option>| (if this command is not defined, then that option is
+silently ignored).
+
+It can be used to provide a `default option list' just before
+|\ProcessOptions|.  For example, suppose that in a class file you want
+to set up the default design to be: two-sided printing; 11pt fonts;
+in two columns. Then it could specify:
+\begin{verbatim}
+   \ExecuteOptions{11pt,twoside,twocolumn}
+\end{verbatim}
+
+
+\subsection{Safe file commands}
+ 
+These commands deal with file input; they ensure that the non-existence
+of a requested file can be handled in a user-friendly way.
+ 
+\begin{decl}
+|\IfFileExists| \arg{file-name} \arg{true} \arg{false}
+\end{decl}
+If the file exists then the code specified in \m{true} is
+executed.
+ 
+If the file does not exist then the code specified in \m{false} is
+executed.
+ 
+This command does \emph{not} input the file.
+
+\begin{decl}
+  |\InputIfFileExists| \arg{file-name} \arg{true} \arg{false}
+\end{decl}
+This inputs the file \m{file-name} if it exists and, immediately
+before the input, the code specified in \m{true} is executed.
+
+If the file does not exist then the code specified in \m{false} is
+executed.
+ 
+It is implemented using |\IfFileExists|.
+
+
+\subsection{Reporting errors, etc}
+ 
+These commands should be used by third party classes and packages to
+report errors, or to provide information to authors.
+ 
+\begin{decl}
+  |\ClassError| \arg{class-name} \arg{error-text} \arg{help-text}\\
+  |\PackageError| \arg{package-name} \arg{error-text} \arg{help-text}
+\end{decl}
+These produce an error message.  The \m{error-text} is displayed and the
+|?| error prompt is shown.  If the user types |h|, they will be shown
+the \m{help-text}.
+ 
+Within the \m{error-text} and \m{help-text}: |\protect| can be used to
+stop a command from expanding; |\MessageBreak| causes a line-break;
+and |\space| prints a space.
+
+Note that the \m{error-text} will have a full stop added to it, so do
+not put one into the argument.
+
+For example:
+\begin{verbatim}
+   \newcommand{\foo}{FOO}
+   \PackageError{ethel}{%
+      Your hovercraft is full of eels,\MessageBreak
+      and \protect\foo\space is \foo
+   }{%
+      Oh dear! Something's gone wrong.\MessageBreak
+      \space \space Try typing \space <<return>>
+      \space to proceed, ignoring \protect\foo.
+   }
+\end{verbatim}
+produces this display:
+\begin{verbatim}
+   ! Package ethel Error: Your hovercraft is full of eels,
+   (ethel)                and \foo is FOO.
+
+   See the ethel package documentation for explanation.
+\end{verbatim}
+If the user types |h|, this will be shown:
+\begin{verbatim}
+   Oh dear! Something's gone wrong.
+     Try typing  <<return>>  to proceed, ignoring \foo.
+\end{verbatim}
+ 
+\begin{decl}
+  |\ClassWarning| \arg{class-name} \arg{warning-text}\\
+  |\PackageWarning| \arg{package-name} \arg{warning-text}\\
+  |\ClassWarningNoLine| \arg{class-name} \arg{warning-text}\\
+  |\PackageWarningNoLine| \arg{package-name} \arg{warning-text}\\
+  |\ClassInfo| \arg{class-name} \arg{info-text}\\
+  |\PackageInfo| \arg{package-name} \arg{info-text}
+\end{decl}
+The four |Warning| commands are similar to the error commands, except
+that they produce only a warning on the screen, with no error prompt.
+
+The first two, |Warning| versions, also show the line number where the
+warning occurred, whilst the second two, |WarningNoLine| versions, do
+not.
+
+The two |Info| commands are similar except that they log the
+information only in the transcript file, including the line number.
+There are no |NoLine| versions of these two.
+
+Within the \m{warning-text} and \m{info-text}: |\protect| can be used to
+stop a command from expanding; |\MessageBreak| causes a line-break;
+and |\space| prints a space.
+Also, these should not end with a full stop as one is
+automatically added.
+ 
+
+\subsection{Defining commands}
+\label{Sec:commands.define}
+ 
+\LaTeXe{} provides some extra methods of (re)defining commands that are
+intended for use in class and package files.
+
+\NEWfeature{1994/12/01}
+The \texttt{*}-forms of these commands should be used to define
+commands that are not, in \TeX{} terms, long.  This can be useful for
+error-trapping with commands whose arguments are not intended to
+contain whole paragraphs of text.
+
+\begin{decl}
+  |\DeclareRobustCommand| \arg{cmd} \oarg{num} \oarg{default}
+     \arg{definition}\\
+  |\DeclareRobustCommand*| \arg{cmd} \oarg{num} \oarg{default}
+     \arg{definition}
+\end{decl}
+This command takes the same arguments as |\newcommand| but it declares
+a robust command, even if some code within the \m{definition} is
+fragile.  You can use this command to define new robust commands, or
+to redefine existing commands and make them robust.  A log is put into
+the transcript file if a command is redefined.
+ 
+For example, if |\seq| is defined as follows:
+\begin{verbatim}
+   \DeclareRobustCommand{\seq}[2][n]{%
+     \ifmmode
+       #1_{1}\ldots#1_{#2}%
+     \else
+       \PackageWarning{fred}{You can't use \protect\seq\space in text}%
+     \fi
+   }
+\end{verbatim}
+Then the command |\seq| can be used in moving arguments, even though
+|\ifmmode| cannot, for example:
+\begin{verbatim}
+   \section{Stuff about sequences $\seq{x}$}
+\end{verbatim}
+
+Note also that there is no need to put a |\relax| before the
+|\ifmmode| at the beginning of the definition; this is because the
+protection given by this |\relax| against expansion at the wrong time
+will be provided internally.
+
+\begin{decl}
+  |\CheckCommand| \arg{cmd} \oarg{num} \oarg{default}
+     \arg{definition}\\
+  |\CheckCommand*| \arg{cmd} \oarg{num} \oarg{default}
+     \arg{definition}
+\end{decl}
+This takes the same arguments as |\newcommand| but, rather than define
+\m{cmd}, it just checks that the current definition of \m{cmd} is
+exactly as given by \m{definition}.  An error is raised if these
+definitions differ.
+ 
+This command is useful for checking the state of the system before
+your package starts altering the definitions of commands.  It allows
+you to check, in particular, that no other package has redefined the
+same command.
+
+\subsection{Moving arguments}
+
+\NEWdescription{1994/12/01}
+The setting of protect whilst processing (i.e.~moving) moving arguments
+has been reimplemented, as has the method of writing information from
+the |.aux| file to other files such as the |.toc| file.  Details can
+be found in the file |ltdefns.dtx|.
+
+We hope that these changes will not affect many packages.
+
+\section{Miscellaneous commands, etc}
+\label{Sec:commands.misc}
+
+\subsection{Layout parameters}
+ 
+\begin{decl}
+|\paperheight|\\
+|\paperwidth|
+\end{decl}
+These two parameters are usually set by the class to be the size of
+the paper being used. This should be actual paper size, unlike
+|\textwidth| and |\textheight| which are the size of the main text
+body within the margins.
+
+
+\subsection{Case changing}
+\label{sec:case}
+
+\begin{decl}
+  |\MakeUppercase| \arg{text} \\
+  |\MakeLowercase| \arg{text}
+\end{decl}
+
+\NEWfeature{1995/06/01}
+\TeX{} provides two primitives |\uppercase| and |\lowercase| for
+changing the case of text.  These are sometimes used in document
+classes, for example to set information in running heads in all
+capitals.
+
+Unfortunately, these \TeX{} primitives do not change the case of
+characters accessed by commands like |\ae| or |\aa|.  To overcome this
+problem, \LaTeX{} provides two new commands |\MakeUppercase| and
+|\MakeLowercase| to do this.
+
+For example:
+\begin{quotation}
+\begin{tabular}{rl}
+   |\uppercase{aBcD\ae\AA\ss\OE}| & \uppercase{aBcD\ae\AA\ss\OE}\\
+   |\lowercase{aBcD\ae\AA\ss\OE}| & \lowercase{aBcD\ae\AA\ss\OE}\\
+   |\MakeUppercase{aBcD\ae\AA\ss\OE}| & 
+                                      \MakeUppercase{aBcD\ae\AA\ss\OE}\\
+   |\MakeLowercase{aBcD\ae\AA\ss\OE}| & \MakeLowercase{aBcD\ae\AA\ss\OE}
+\end{tabular}
+\end{quotation}
+
+The commands |\MakeUppercase| and |\MakeLowercase| themselves are
+robust, but they have moving arguments.
+
+The commands use the \TeX{} primitives |\uppercase| and |\lowercase|,
+and so have a number of unexpected `features'.  In particular, they
+change the case of everything (except characters in the names of
+control-sequences) in their text argument: this includes mathematics,
+environment names, and label names.
+
+For example:
+\begin{verbatim}
+   \MakeUppercase{$x+y$ in \ref{foo}}
+\end{verbatim}
+produces $X+Y$ and the warning:
+\begin{verbatim}
+   LaTeX Warning: Reference `FOO' on page ... undefined on ...
+\end{verbatim}
+In the long run, we would like to use all-caps fonts rather than any
+command like |\MakeUppercase| but this is not possible at the moment
+because such fonts do not exist.
+
+\NEWdescription{1995/12/01}
+In order that upper/lower-casing will work reasonably well, and in
+order to provide any correct hyphenation, \LaTeXe{} \emph{must} use,
+throughout a document, the same fixed table for changing case.
+The table used is designed for the font encoding |T1|; this works well
+with the standard \TeX{} fonts for all Latin alphabets but will cause
+problems when using other alphabets.
+
+\subsection{The `openany' option in the `book' class}
+
+\NEWdescription{1996/06/01}
+The |openany| option allows chapter and similar openings to
+occur on left hand pages. Previously this option affected only
+|\chapter| and |\backmatter|.  It now also affects
+|\part|, |\frontmatter| and |\mainmatter|.
+
+\subsection{Better user-defined math display environments}
+
+\begin{decl}
+  |\ignorespacesafterend|
+\end{decl}
+
+\NEWfeature{1996/12/01}
+\NEWdescription{2003/12/01}
+Suppose that you want to define an environment for displaying text
+that is numbered as an equation.  A straightforward way to do this is
+as follows:
+\begin{verbatim}
+  \newenvironment{texteqn}
+    {\begin{equation}
+       \begin{minipage}{0.9\linewidth}}
+      {\end{minipage}
+     \end{equation}}
+\end{verbatim}
+However, if you have tried this then you will probably have noticed
+that it does not work perfectly when used in the middle of a paragraph
+because an inter-word space appears at the beginning of the first
+line after the environment.
+
+There is now an extra command (with a very long name) available that
+you can use to avoid this problem; it should be inserted as shown here:
+\begin{verbatim}
+  \newenvironment{texteqn}
+    {\begin{equation}
+       \begin{minipage}{0.9\linewidth}}
+      {\end{minipage}
+     \end{equation}
+     \ignorespacesafterend}
+\end{verbatim}
+
+This command may also have other uses.
+
+\subsection{Normalising spacing}
+
+\begin{decl}
+  |\normalsfcodes|
+\end{decl}
+
+\NEWfeature{1997/06/01}
+This command should be used to restore the normal settings of the
+parameters that affect spacing between words, sentences, etc.
+
+An important use of this feature is to correct a problem, reported by
+Donald Arseneau, that punctuation in page headers has always (in all
+known \TeX{} formats) been potentially wrong whenever a page break
+happens while a local setting of the space codes is in effect.  These
+space codes are changed by, for example, the command
+\verb|\frenchspacing|) and the \textsf{verbatim} environment.
+
+It is normally given the correct definition automatically in
+|\begin{document}| and so need not be explicitly set; however, if it
+is explicitly made nonempty in a class file then automatic
+default setting will be over-ridden.
+
+
+\section{Upgrading \LaTeX~2.09 classes and packages}
+\label{Sec:upgrade}
+ 
+This section describes the changes you may need to make when you
+upgrade an existing \LaTeX{} style to a package or class but we shall
+start in optimistic mode.
+ 
+Many existing style files will run with \LaTeXe{} without any
+modification to the file itself.  When everything is running OK,
+please put a note in the newly created package or class file to record
+that it runs with the new standard \LaTeX{}; then distribute it to
+your users.
+
+\subsection{Try it first!}
+\label{Sec:try-it}
+
+The first thing you should do is to test your style in `compatibility
+mode'.  The only change you need to make in order to do this is,
+possibly, to change the extension of the file to |.cls|: you should
+make this change only if your file was used as a main document style.
+Now, without any other modifications, run \LaTeXe{} on a document that
+uses your file.  This assumes that you have a suitable collection of
+files that tests all the functionality provided by your style file.
+(If you haven't, now is the time to make one!)
+
+You now need to change the test document files so that they are
+\LaTeXe{} documents: see \emph{\usrguide} for details of how to do
+this and then try them again.  You have now tried the test documents
+in both \LaTeXe{} native mode and \LaTeX~2.09 compatibility mode.
+
+\subsection{Troubleshooting}
+\label{Sec:trouble}
+
+If your file does not work with \LaTeXe{}, there are two likely
+reasons.
+\begin{itemize}
+\item \LaTeX{} now has a robust, well-defined designer's interface for
+  selecting fonts, which is very different from the \LaTeX~2.09
+  internals.  
+\item Your style file may have used some \LaTeX~2.09 internal commands
+  which have changed, or which have been removed.
+\end{itemize}
+
+When you are debugging your file, you will probably need more
+information than is normally displayed by \LaTeXe.  This is achieved
+by resetting the counter |errorcontextlines| from its default value of
+$-1$ to a much higher value, e.g.~999.
+
+\subsection{Accommodating compatibility mode}
+
+Sometimes an existing collection of \LaTeX~2.09 documents makes it
+inconvenient or impossible to abandon the old commands entirely.
+If this is the case, then it is possible to accommodate both conventions
+by making special provision for documents processed in compatibility
+mode.
+
+\begin{decl}
+|\if@compatibility|
+\end{decl}
+This switch is set when a document begins with |\documentstyle| rather
+than |\documentclass|.  Appropriate code can be supplied for either
+condition, as follows:
+\begin{verbatim}
+   \if@compatibility
+     <code emulating LaTeX 2.09 behavior>
+   \else
+     <code suitable for LaTeX2e>
+   \fi
+\end{verbatim}
+
+
+\subsection{Font commands}
+ 
+Some font and size commands are now defined by the document class
+rather than by the \LaTeX{} kernel.  If you are upgrading a
+\LaTeX~2.09 document style to a class that does not load one of the
+standard classes, then you will probably need to add definitions for
+these commands.
+ 
+\begin{decl}
+   |\rm| |\sf| |\tt| |\bf| |\it| |\sl| |\sc|
+\end{decl}
+None of these short-form font selection commands are defined in the
+\LaTeXe{} kernel.  They are defined by all the standard class files.
+
+If you want to define them in your class file, there are several
+reasonable ways to do this.
+
+One possible definition is:
+\begin{verbatim}
+   \newcommand{\rm}{\rmfamily}
+   ...
+   \newcommand{\sc}{\scshape}
+\end{verbatim}
+This would make the font commands orthogonal; for example
+|{\bf\it text}| would produce bold italic, thus: \textbf{\textit{text}}.
+It will also make them produce an error if used in math mode.
+ 
+Another possible definition is:
+\begin{verbatim}
+   \DeclareOldFontCommand{\rm}{\rmfamily}{\mathrm}
+   ...
+   \DeclareOldFontCommand{\sc}{\scshape}{\mathsc}
+\end{verbatim}
+This will make |\rm| act like |\rmfamily| in text mode (see above) and
+it will make |\rm| select the |\mathrm| math alphabet in math mode.
+
+Thus |${\rm math} = X + 1$| will produce `${\rm math} = X + 1$'.
+
+If you do not want font selection to be orthogonal then you can
+follow the standard classes and define:
+\begin{verbatim}
+   \DeclareOldFontCommand{\rm}{\normalfont\rmfamily}{\mathrm}
+   ...
+   \DeclareOldFontCommand{\sc}{\normalfont\scshape}{\mathsc}
+\end{verbatim}
+This means, for example, that |{\bf\it text}| will produce medium
+weight (rather than bold) italic, thus: \textit{text}.  
+
+\begin{decl}
+   |\normalsize| \\
+   |\@normalsize|
+\end{decl}
+The command |\@normalsize| is retained for compatibility with
+\LaTeX~2.09 packages which may have used its value; but redefining it
+in a class file will have no effect since it is always reset to have
+the same meaning as |\normalsize|.
+
+This means that classes \emph{must} now redefine |\normalsize| rather
+than redefining |\@normalsize|; for example (a rather incomplete one):
+\begin{verbatim}
+   \renewcommand{\normalsize}{\fontsize{10}{12}\selectfont}
+\end{verbatim}
+Note that |\normalsize| is defined by the \LaTeX{} kernel to be an
+error message.
+
+\begin{decl}
+   |\tiny| |\footnotesize| |\small| |\large|\\
+   |\Large| |\LARGE| |\huge| |\Huge|
+\end{decl}
+None of these other `standard' size-changing commands are defined in
+the kernel: each needs to be defined in a class file if you need it.
+They are all defined by the standard classes.
+
+This means you should use |\renewcommand| for |\normalsize| and
+|\newcommand| for the other size-changing commands.
+
+
+\subsection{Obsolete commands}
+ 
+Some packages will not work with \LaTeXe{}, normally because they relied
+on an internal \LaTeX{} command which was never supported and has now
+changed, or been removed.
+ 
+In many cases there will now be a robust, high-level means of
+achieving what previously required low-level commands.  Please consult
+Section~\ref{Sec:commands} to see if you can now use the \LaTeXe{}
+class and package writers commands.
+
+Also, of course, if your package or class redefined any of the kernel
+commands (i.e.~those defined in the files |latex.tex|, |slitex.tex|,
+|lfonts.tex|, |sfonts.tex|) then you will need to check it very
+carefully against the new kernel in case the implementation has
+changed or the command no longer exists in the \LaTeX2e{} kernel.
+
+Too many of the internal commands of \LaTeX~2.09 have been
+re-implemented or removed to be able to list them all here. You must
+check any that you have used or changed.
+
+We shall, however, list some of the more important commands which are
+no longer supported.
+ 
+\begin{decl}
+   |\tenrm| |\elvrm| |\twlrm| \dots\\
+   |\tenbf| |\elvbf| |\twlbf| \dots\\
+   |\tensf| |\elvsf| |\twlsf| \dots\\
+   \qquad$\vdots$
+\end{decl}
+The (approximately) seventy internal commands of this form are no longer
+defined.  If your class or package uses them then \emph{please}
+replace them with new font commands described in \emph{\fntguide}.
+
+For example, the command |\twlsf| should be replaced by:
+\begin{verbatim}
+   \fontsize{12}{14}\normalfont\sffamily\selectfont
+\end{verbatim}
+
+Another possibility is to use the |rawfonts| package, described in
+\emph{\usrguide}.
+
+Also, remember that many of the fonts preloaded by \LaTeX~2.09 
+are no longer preloaded.
+
+\begin{decl}
+   |\vpt| |\vipt| |\viipt| \dots
+\end{decl}
+These were the internal size-selecting commands in \LaTeX~2.09.
+(They can still be used in \LaTeX~2.09 compatibility mode.)
+Please use the command |\fontsize| instead: see \emph{\fntguide} for
+details.
+
+For example, |\vpt| should be replaced by:
+\begin{verbatim}
+   \fontsize{5}{6}\normalfont\selectfont
+\end{verbatim}
+
+\begin{decl}
+  |\prm|, |\pbf|, |\ppounds|, |\pLaTeX| \dots
+\end{decl}
+\LaTeX~2.09 used several commands beginning with |\p| in order to
+provide `protected' commands.  For example, |\LaTeX| was defined to be
+|\protect\pLaTeX|, and |\pLaTeX| was defined to produce the \LaTeX{}
+logo.  This made |\LaTeX| robust, even though |\pLaTeX| was not.
+
+These commands have now been reimplemented using
+|\DeclareRobustCommand|
+(described in Section~\ref{Sec:commands.define}).
+If your package redefined one of the |\p|-commands then you must
+remove the redefinition and use |\DeclareRobustCommand| to redefine the
+non-|\p| command.
+ 
+\begin{decl}
+|\footheight|\\
+|\@maxsep|\\
+|\@dblmaxsep|
+\end{decl}
+These parameters are not used by \LaTeXe{} so they have been removed,
+except in \LaTeX~2.09 compatibility mode.  Classes should no longer
+set them.
+ 
+\begin{thebibliography}{1}
+ 
+\bibitem{A-W:DEK91}
+Donald~E. Knuth.
+\newblock {\em The \TeX book}.
+\newblock Addison-Wesley, Reading, Massachusetts, 1986.
+\newblock Revised to cover \TeX3, 1991.
+ 
+\bibitem{A-W:LLa94}
+Leslie Lamport.
+\newblock {\em {\LaTeX:} A Document Preparation System}.
+\newblock Addison-Wesley, Reading, Massachusetts, second edition, 1994.
+ 
+\bibitem{A-W:MG2004}
+Frank Mittelbach and Michel Goossens.
+\newblock {\em The {\LaTeX} Companion second edition}.
+\newblock With Johannes Braams, David Carlisle, and Chris Rowley.
+\newblock Addison-Wesley, Reading, Massachusetts, 2004.
+
+\end{thebibliography}
+
+\newpage
+\thispagestyle{empty}
+
+\section*{\LaTeXe{} Summary sheet: updating old styles}
+
+Section references below are to \emph{\clsguide}.
+
+\begin{enumerate}
+
+\item Should it become a class or a package?
+  See Section~\ref{Sec:classorpkg} for how to answer this question.
+
+\item If it uses another style file, then you will need to obtain an
+  updated version of this other file.  Look at Section~\ref{Sec:loading}
+  for information on how to load other class and package files.
+
+\item Try it: see Section~\ref{Sec:try-it}.
+
+\item It worked?  Excellent, but there are probably still some things
+  you should change in order to make your file into a well-structured
+  \LaTeXe{} file that is both robust and portable. So you should now
+  read Section~\ref{Sec:writing}, especially~\ref{Sec:general}.  You
+  will also find some useful examples in Section~\ref{Sec:structure}.
+
+  If your file sets up new fonts, font-changing commands or symbols,
+  you should also read \emph{\fntguide}.
+  
+\item It did not work?  There are three possibilities here:
+  \begin{itemize}
+  \item  error messages are produced whilst reading your file;
+  \item  error messages are produced whilst processing test documents;
+  \item  there are no errors but the output is not as it should be.
+  \end{itemize}
+  Don't forget to check carefully for this last possibility.
+
+  If you have got to this stage then you will need to read
+  Section~\ref{Sec:upgrade} to find the solutions that will make your
+  file work.
+\end{enumerate}
+
+\end{document}
+
-- 
cgit v1.2.3

