% \iffalse meta-comment
%
% Copyright 1993 1994 1995 1996 1997 1998 1999
% 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.2
% 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.2 or later is part of all distributions of LaTeX 
% version 1999/12/01 or later.
% 
% 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.
% 
% \fi
% Filename: clsguide.tex

\NeedsTeXFormat{LaTeX2e}[1995/12/01]

\documentclass{ltxguide}[1995/11/28]

\usepackage[T1]{fontenc}
\usepackage[frenchb]{babel}


\title{\LaTeXe~pour les auteurs de classes et packages
\thanks{traduit par S.~\textsc{Le Callonnec} (\texttt{<sebastien.le-callonnec@eleve.emn.fr>}) le 6 f\'evrier 1999. 
	Titre original~: <<~\LaTeXe~for class and package writers~>>}}

\author{Copyright \copyright~1995--1998 The \LaTeX3 Project\\ Tous droits r\'eserv\'es}

\date{12 mars 1999} 

\begin{document}
 
\maketitle
 
\tableofcontents
 
\section{Introduction}

Ce document est une introduction \`a l'\'ecriture de classes et packages pour
\LaTeX{}, avec une attention  particuli\`ere donn\'ee \`a la mise \`a jour des packages
\LaTeX~2.09 vers \LaTeXe{}. Ce sujet est \'egalement trait\'e par un article de
Johannes Braams publi\'e dans TUGboat~15.3.

\subsection{\'Ecriture de classes et packages pour \LaTeXe}
 
\LaTeX{} est un  syst\`eme de pr\'eparation de document qui permet \`a l'auteur du 
document de se concentrer  sur le contenu de son texte, sans avoir trop \`a se soucier de 
la mise en forme de celui-ci. Par exemple, les chapitres sont indiqu\'es par 
|\chapter{<title>}| plut\^ot que par la s\'election du 18 pt, gras.

Le fichier qui contient l'information concernant le passage de la structure 
logique (comme <<~|\chapter|~>>) \`a la composition (comme <<~18 pt gras en drapeau 
\`a droite~>>) est une \emph{classe de document}.  De surcroît, certaines 
caract\'eristiques (telles que l'usage de la couleur ou des graphiques inclus) sont 
ind\'ependantes de la classe de document, et sont contenues dans des 
\emph{packages}.

Une des plus grandes diff\'erences entre \LaTeX~2.09 et \LaTeXe{} r\'eside dans les 
commandes utilis\'ees pour r\'ediger les packages et classes. En \LaTeX~2.09, il 
existait peu d'appuis pour \'ecrire les fichiers |.sty| et les r\'edacteurs devaient 
recourir \`a des commandes de bas niveau.


\LaTeXe{} fournit des  commandes de haut niveau afin de structurer les packages. Il 
est \'egalement plus facile de construire des classes et packages sur d'autres, 
pour \'ecrire par exemple une classe pour un rapport technique local |cetechr| 
(pour le d\'epartement du G\'enie Chimique\footnote{NdT~: <<~Chemical 
Engineering department~>>}) bas\'ee sur |article|.
 
\subsection{Aper\c{c}u}
 
Ce document contient un aper\c{c}u sur la fa\c{c}on d'\'ecrire des classes et
packages pour \LaTeX{}.  Il  \emph{n'\emph{introduit} pas} toutes les
commandes n\'ecessaires pour \'ecrire des packages~: celles-ci peuvent \^etre trouv\'ees dans le
\emph{\LaTeXbook} ou \emph{\LaTeXcomp}.  Il d\'ecrit cependant les nouvelles
commandes pour structurer les classes et packages.

\begin{description}
 
 \item[La section~\ref{Sec:general}] contient quelques conseils g\'en\'eraux 
 concernant l'\'ecriture de classes et packages.  Elle d\'ecrit la diff\'erence entre 
 classes et packages, les conventions de nommage des commandes, l'utilisation de 
 |doc| et |docstrip|, comment les commandes de gestion des boîtes et des fichiers 
 de \TeX\ interagissent avec \LaTeX{}. Elle contient \'egalement quelques conseils sur le 
 style g\'en\'eral de \LaTeX{}.

 \item[La section~\ref{Sec:structure}] d\'ecrit la structure des classes   et 	
 packages.  Ceci inclut la construction de classes et packages sur d'autres 
 classes et packages, la d\'eclaration d'options et de commandes. Elle contient 
 \'egalement des classes exemples.

 \item[La section~\ref{Sec:commandes}] liste les nouvelles commandes de classe et 
	package.

 
 \item[La section~\ref{Sec:upgrade}] donne des conseils d\'etaill\'es sur la fa\c{c}on
 de mettre \`a jour les classes et packages \LaTeX~2.09 vers \LaTeXe{}.
 
\end{description}
 
\subsection{Pour plus d'informations}
 
Pour une introduction  g\'en\'erale \`a \LaTeX{}, y compris les nouvelles fonctionnalit\'es de
\LaTeXe{}, vous devriez lire \emph{\LaTeXbook}
de Leslie Lamport~\cite{A-W:LLa94}.
 
Une description plus d\'etaill\'ee des nouvelles fontionnalit\'es de \LaTeX{}, et un
aper\c{c}u de plus de 150 packages, peuvent \^etre trouv\'es dans 
\emph{\LaTeXcomp}, un livre de Michel Goossens, Frank Mittelbach et Alexander
Samarin~\cite{A-W:GMS94}.
 
Le syst\`eme \LaTeX{} est bas\'e sur \TeX{}, qui est
d\'ecrit dans \emph{The \TeX book} de Donald E.~Knuth~\cite{A-W:DEK91}.
 
Il y a nombre de fichiers de documentation qui accompagnent chaque copie
de \LaTeX{}.  Une copie des \emph{\LaTeX{} News} sort avec chaque version
de \LaTeX{} \'edit\'ee tous les 6 mois, et peut \^etre trouv\'ee dans les fichiers
|ltnews*.tex|.  Le guide de l'auteur \emph{\usrguide} d\'ecrit les nouvelles
caract\'eristiques de document \LaTeX{}; il se trouve dans |usrguide.tex|.  Le guide
\emph{\fntguide} d\'ecrit le proc\'ed\'e de s\'election de fonte  \LaTeX{} pour 
les r\'edacteurs de classes et packages; il se trouve dans |fntguide.tex|. La configuration de
\LaTeX{} est trait\'ee par le guide \emph{\cfgguide} dans le fichier
\texttt{cfgguide.tex} tandis que la  philosophie derri\`ere notre politique de
modification de \LaTeX{} est d\'ecrite dans \emph{\modguide} dans le fichier
\texttt{modguide.tex}.

Nous transcrivons progressivement le code source de \LaTeX{} en un document
\LaTeX{} \emph{\sourcecode}.  Ce document inclut un index des
commandes \LaTeX{}  et peut \^etre compos\'e \`a partir de |source2e.tex|.
 
Pour plus  d'informations sur \TeX{} et \LaTeX{}, veuillez contacter votre
Groupe local d'Utilisateurs de \TeX{}, ou le Groupe international des Utilisateurs de \TeX{}.

Voici quelques adresses utiles.
\begin{quote}\small\label{addrs}
   \TeX{} Users Group, P.O. Box 1239, Three Rivers, CA~93271-1239, USA\\
   Fax:~+1~209~561~4584 \ Email: \texttt{tug@mail.tug.org}
 
   UK TUG, 1 Eymore Close, Selly Oak, Birmingham B29~4LB, UK\\
   Fax: +44 121 476 2159 \ Email: \texttt{uktug-enquiries@tex.ac.uk}
   
   GUTenberg, c/o Irisa, Campus universitaire de Beaulieu\\
   F-35042 Rennes Cedex, France\\
   Fax:~+33~(0)5~61~52~83~44 \ Email: \texttt{secretariat@gutenberg.eu.org}
\end{quote}
 

\subsection{Politique sur les classes standard}

Beaucoup des probl\`emes signal\'es que nous recevons concernant les classes 
standard ne sont pas d\^us \`a des bogues, mais sugg\`erent, plus ou moins poliment, que 
les d\'ecisions de design prises pour ces classes ne sont <<~pas optimales~>> et 
nous demandent de les modifier.

Il y a plusieurs raisons pour lesquelles nous ne devrions pas faire de tels
changements \`a ces fichiers.
\begin{itemize}
\item
  M\^eme s'il est malavis\'e, le comportement actuel est clairement ce qui \'etait
  attendu lors du design de ces classes.
\item
  Ce n'est pas une bonne pratique de changer des aspects des <<~classes standard~>>
  car beaucoup de gens comptent sur elles.
\end{itemize}

Nous avons par cons\'equent d\'ecid\'e de ne pas  consid\'erer l'\'eventualit\'e de 
telles modifications ni m\^eme de perdre du temps \`a justifier cette d\'ecision.
Ceci ne signifie pas que nous ne sommes pas d'accord qu'il y a beaucoup
de d\'eficiences dans le design de ces classes, mais nous avons des tâches
de plus haute priorit\'e que d'expliquer pourquoi les classes standard de 
\LaTeX{} ne peuvent \^etre chang\'ees.


Les productions de meilleures classes ou de packages am\'eliorant ces classes 
seraient bien s\^ur les bienvenues. Quand vous r\'efl\'echirez \`a une telle d\'eficience, 
votre premi\`ere pens\'ee sera, nous l'esp\'erons,
 <<~Comment puis-je am\'eliorer ceci?~>>
 
Des consid\'erations similaires peuvent \^etre appliqu\'ees aux parties du noyau
impl\'ementant des d\'ecisions de design, dont beaucoup devraient \^etre laiss\'ees 
au fichier de classe et ne le sont pas dans le syst\`eme actuel. Nous r\'ealisons 
que dans de tels cas, il est plus difficile pour vous de rectifier le probl\`eme
vous-m\^eme mais faire  de tels changements dans le noyau serait certainement un 
projet majeur pour nous. Par cons\'equent, de telles
am\'eliorations devront attendre \LaTeX3.

\section{\'Ecriture de classes et packages}
\label{Sec:writing}
 
Cette section recouvre quelques points g\'en\'eraux quant \`a l'\'ecriture de classes et 
packages \LaTeX{}.


\subsection{Anciennes versions}

Si vous \^etes en train de mettre \`a jour un fichier de style \LaTeX~2.09 d\'ej\`a existant,
nous vous recommandons de geler la version 2.09 et de ne plus la maintenir.
L'exp\'erience acquise avec les diff\'erents dialectes  de \LaTeX{} qui existaient 
au d\'ebut des ann\'ees 90 montre que le maintien de packages pour diff\'erentes versions
de \LaTeX{} est presque impossible.  Il sera bien s\^ur n\'ecessaire 
pour certaines organisations de maintenir les deux versions en parall\`ele pendant 
quelques temps mais ceci n'est pas essentiel pour les packages et classes 
g\'er\'es par des particuliers~: ils ne devraient g\'erer que le nouveau standard
\LaTeXe{}, et non les versions obsol\`etes de \LaTeX{}.


\subsection{Utilisation de <<~docstrip~>> et <<~doc~>>}
 
Lorsque vous \'ecrivez un gros package ou classe pour \LaTeX{}, il vous
faut alors consid\'erer l'utilisation du programme |doc| livr\'e avec
\LaTeX{}. 
Les classes et packages \LaTeX{} \'ecrits en l'utilisant peuvent \^etre 
trait\'es de deux fa\c{c}ons: ils peuvent \^etre ex\'ecut\'es par \LaTeX{}, pour produire la
documentation; ils peuvent \'egalement \^etre trait\'es par |docstrip|, pour produire
le fichier |.cls| ou |.sty|.
 
Le programme |doc| peut automatiquement produire les index de d\'efinitions,
les index des commandes et les listes de transcription des changements. Ceci
est particuli\`erement utile pour le maintien et la documentation de larges
sources \TeX{}.
 
Les sources document\'ees du noyau \LaTeX{} lui-m\^eme, et des classes
standard, etc., sont des documents |doc|; ils se trouvent dans les fichiers |.dtx|
de la distribution.  Vous pouvez en fait composer le code source du noyau comme
un long document, compl\'et\'e par un index, en ex\'ecutant \LaTeX{} sur |source2e.tex|.
 
Pour plus d'informations concernant |doc| et |docstrip|, consultez les fichiers
|docstrip.dtx|, |doc.dtx|, et \emph{\LaTeXcomp}.  Pour des exemples d'utilisation,
regardez ces fichiers |.dtx|.

\subsection{Est-ce une classe ou un package?}
\label{Sec:classorpkg}
 
La premi\`ere chose \`a faire quand vous voulez mettre de nouvelles commandes \LaTeX{} 
dans un fichier est de d\'ecider si ce fichier doit \^etre une \emph{classe de document} ou un
\emph{package}. En r\`egle g\'en\'erale~:
\begin{quote}
  Si les commandes peuvent \^etre utilis\'ees dans n'importe quelle classe de document,
  faites alors un package; sinon, faites-en une classe.
\end{quote}

Il y a deux principaux types de classes: celles, comme |article|, |report| ou 
|letter|, qui existent par elles-m\^eme, et celles qui ne sont que des extensions 
ou variations d'autres classes ---  la classe de document |proc|, par exemple, 
qui est construite sur la classe de document |article|.

Une entreprise peut avoir ainsi une classe locale |ownlet| pour imprimer des 
lettres avec leur propre ent\^ete. Une telle classe serait construite par-dessus 
la classe |letter| existante mais, ne pouvant \^etre utilis\'ee par aucune autre 
classe, serait appel\'ee |ownlet.cls|
plut\^ot que |ownlet.sty|.
 
Le package |graphics|, au contraire, fournit des commandes pour l'inclusion 
d'images dans un  document \LaTeX{}.  Du fait que ces  commandes peuvent \^etre  
 utilis\'ees avec n'importe quelle  classe de document, nous avons un 
fichier |graphics.sty| plut\^ot que |graphics.cls|.
 

\subsection{Noms de commandes}
 
\LaTeX{} poss\`ede trois types de commandes.
 
Il y a les commandes de l'auteur, telles que |\section|, |\emph| et
|\times|:  la plupart d'entre elles poss\`edent un nom court, en bas de casse.
 
Il y a \'egalement les commandes du r\'edacteur de classes et packages: la plupart 
d'entre elles ont des noms m\'elangeant haut et bas de casse, comme celles qui
 suivent:
\begin{verbatim}
   \InputIfFileExists  \RequirePackage  \PassOptionsToClass
\end{verbatim}
 
Enfin, il y a les commandes internes utilis\'ees pour l'impl\'ementation \LaTeX{}, 
telles que |\@tempcnta|, |\@ifnextchar| et |\@eha|: la plupart de ces commandes 
contiennent |@| dans leur nom, ce qui veut dire qu'elle ne peuvent \^etre 
utilis\'ees dans des documents, et seulement dans les fichiers de classes et packages.
 
Malheureusement, pour des raisons historiques, la distinction entre ces commandes est
souvent floue. |\hbox| est, par exemple, une commande interne 
qui ne devrait \^etre utilis\'ee que dans le noyau \LaTeX{}, alors que
|\m@ne| est la constante $-1$ et aurait pu \^etre appel\'ee |\MinusOne|.
 
Ces indications restent toutefois utiles: si une commande poss\`ede |@| dans
son nom, elle n'appartient alors pas au langage \LaTeX{} g\'er\'e --- et son
comportement peut changer dans de futures versions!  Si une commande contient
des majuscules et minuscules ou est d\'ecrite dans \emph{\LaTeXbook}, vous pouvez
alors compter sur le fait que les futures versions de \LaTeXe{} g\'ereront cette commande.
 
\subsection{Commandes de boîtes et couleur}
\label{Sec:colour}
 
M\^eme si vous n'avez pas l'intention d'utiliser la couleur dans vos propres
documents, vous pouvez vous assurer en prenant note des points d\'evelopp\'es dans
cette section que votre
classe ou package est compatible avec le  package |color|. Ceci peut profiter
aux gens utilisant votre classe ou package et ayant acc\`es \`a une imprimante couleur.
 
Le moyen le plus facile pour assurer la <<~s\'ecurit\'e couleur~>> est de toujours 
utiliser les commandes de boîtes de \LaTeX{} plut\^ot que les  primitives \TeX{}, 
ce qui veut dire utiliser |\sbox| plut\^ot que |\setbox|, |\mbox| plut\^ot que 
|\hbox| et |\parbox| ou l'environnement |minipage| plut\^ot que |\vbox|. 
Les commandes de boîtes \LaTeX{} poss\`edent de nouvelles options, ce qui signifie 
qu'elles sont plus puissantes que les primitives \TeX{}.
 
Comme exemple de ce qui peut poser probl\`eme, pensez que dans 
|{\ttfamily <text>}|,
la fonte est restaur\'ee juste \emph{avant} l'|}|, alors que dans la 
construction d'apparence similaire
|{\color{green} <text>}|
la couleur est restaur\'ee juste \emph{apr\`es} l'|}| finale. Normalement, cette 
distinction n'a aucune importance; mais consid\'erez une assignation primitive \TeX{}
de boîte telle que:
\begin{verbatim}
   \setbox0=\hbox{\color{green} <text>}
\end{verbatim}
La restauration de couleur intervient alors apr\`es l'|}| et donc \emph{n'\emph{est} pas}
sauv\'ee dans la boîte. Les mauvais effets que ceci peut avoir d\'epend exactement de la fa\c{c}on
dont la couleur est impl\'ement\'ee: cela peut aller de la mauvaise couleur dans le reste du document \`a l'obtention d'erreurs dans le pilote dvi utilis\'e pour imprimer le document.
 
La commande |\normalcolor| a \'egalement son int\'er\^et. Elle n'est en temps normal 
que |\relax| (i.e., ne fait rien),
mais vous pouvez l'utiliser plut\^ot comme |\normalfont| pour passer
des r\'egions de la page telles que l\'egendes ou ent\^etes de sections \`a la 
<<~couleur principale du document~>>.


\subsection{D\'efinition de caract\`eres de texte et de maths}
\label{Sec:chars}

Parce que \LaTeXe{} g\`ere diff\'erents encodages, les d\'efinitions de commandes
pour produire symboles, accents,  glyphes composites, etc.\ doivent \^etre
faites en utilisant les commandes d\'evelopp\'ees \`a cette fin et d\'ecrites dans
\emph{\fntguide}.  Cette partie du syst\`eme est encore en d\'eveloppement; c'est 
pourquoi de telles tâches doivent \^etre entreprises avec pr\'ecaution.

De plus, |\DeclareRobustCommand| devrait \^etre utilis\'e pour d\'efinir  des commandes de ce type, ind\'ependantes de l'encodage.

Notez qu'il n'est plus possible de faire r\'ef\'erence aux jeux de caract\`eres math\'ematiques 
en dehors du mode math\'ematique: par exemple ni |\textfont 1| ni
|\scriptfont 2| n'ont la garantie d'\^etre d\'efinis dans d'autres modes.


\subsection{Style g\'en\'eral}
\label{Sec:general}

Le nouveau syst\`eme fournit beaucoup de commandes \'etudi\'ees pour vous aider \`a
produire des fichiers de classes et packages bien structur\'es, \`a la fois robustes et portables.
Cette section esquisse quelques fa\c{c}ons de les utiliser intelligemment.

\subsubsection{Charger d'autres fichiers}
\label{Sec:loading}

\NEWdescription{1995/12/01}
\LaTeX{} fournit les commandes: 
\begin{verbatim}
   \LoadClass        \LoadClassWithOptions
   \RequirePackage   \RequirePackageWithOptions
\end{verbatim}
pour utiliser des classes ou packages \`a l'int\'erieur d'autres classes ou packages. Nous
vous recommandons express\'ement de les utiliser plut\^ot que la commande primitive
|\input| pour un certain nombre de raisons.
 
Les fichiers charg\'es par |\input <filename>| ne seront pas r\'epertori\'es dans la
liste |\listfiles|.
 
Si un package est toujours charg\'e avec |\RequirePackage...| ou |\usepackage|
alors m\^eme si son chargement est demand\'e plusieurs fois, il ne sera toujours fait qu'une seule fois. 
Au contraire, s'il est charg\'e avec |\input|, il peut \^etre alors charg\'e plus d'une fois. Un tel chargement suppl\'ementaire peut faire perdre \`a la fois temps et m\'emoire et peut amener \`a de 
bien \'etranges r\'esultats.

Si un package fournit un traitement d'option, l\`a encore d'\'etranges r\'esultats sont possibles si le package est charg\'e par  |\input| plut\^ot que par
|\usepackage| or |\RequirePackage...|.
 
Si le package |foo.sty| charge le package |baz.sty| en utilisant
|\input baz.sty|, alors l'utilisateur obtiendra l'avertissement:
\begin{verbatim}
   LaTeX Warning: You have requested package `foo',
                  but the package provides `baz'.
\end{verbatim}
Ainsi, pour plusieurs raisons, l'utilisation de |\input| pour charger des packages n'est pas une bonne id\'ee.
 
Malheureusement, si vous mettez \`a jour le fichier |myclass.sty| pour en faire une classe
de document, il vous faut vous assurer que les anciens fichiers contenant 
|\input myclass.sty| marchent encore.

Ceci \'etait \'egalement vrai pour les classes standard (|article|, |book| et
|report|), car beaucoup des styles de document \LaTeX~2.09 existants contiennent
|\input article.sty|.  L'approche que nous utilisons afin de r\'esoudre ceci est de
fournir des fichiers minimaux |article.sty|, |book.sty| et |report.sty|,
qui chargent tout simplement les fichiers de classe appropri\'es.

Par exemple, |article.sty| ne contient juste que les lignes suivantes:
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}
   \@obsoletefile{article.cls}{article.sty}
   \LoadClass{article}
\end{verbatim}
Vous pouvez d\'esirer faire de m\^eme ou, si vous pensez que c'est sans danger, d\'ecider de simplement \^oter |myclass.sty|.
 
\subsubsection{Faire dans le robuste}

Nous consid\'erons comme un bon entraînement l'utilisation lors de l'\'ecriture de 
 packages et classes des commandes \LaTeX{} autant que possible.

Ainsi, \`a la place de |\def...|, nous recommandons d'utiliser
|\newcommand|, |\renewcommand| ou |\providecommand|; |\CheckCommand| est
\'egalement utile. Il y a moins de risque en faisant ceci que
vous red\'efinissiez par inadvertance une commande, donnant des 
r\'esultats pour le moins inattendus.
 
Quand vous d\'efinissez un environnement, utilisez |\newenvironment| ou
|\renewenvironment| au lieu de |\def\foo{...}| et |\def\endfoo{...}|.
 
Si vous avez besoin d'\'etablir ou de changer la valeur d'un registre \m{dimen} ou \m{skip},
utilisez |\setlength|.
 
Pour manipuler des boîtes, utilisez les commandes \LaTeX{} telles que |\sbox|,
|\mbox| et |\parbox| plut\^ot que |\setbox|, |\hbox| et |\vbox|.
 
Utilisez |\PackageError|, |\PackageWarning| ou |\PackageInfo| (ou les commandes de classes \'equivalentes) plut\^ot que |\@latexerr|, |\@warning| ou
|\wlog|.
 
Il est encore possible de d\'eclarer des options en d\'efinissant |\ds@<option>| et 
en appelant |\@options|; nous recommandons cependant d'employer les commandes |\DeclareOption| et
|\ProcessOptions| \`a la place. Ces derni\`eres sont en effet plus puissantes
et utilisent moins de m\'emoire. Donc, plut\^ot que d'utiliser:
\begin{verbatim}
   \def\ds@draft{\overfullrule 5pt}
   \@options
\end{verbatim}
vous devriez utiliser:
\begin{verbatim}
   \DeclareOption{draft}{\setlength{\overfullrule}{5pt}}
   \ProcessOptions\relax
\end{verbatim}

L'avantage de ce genre de pratique est que votre code est plus lisible et, plus important, qu'il est moins expos\'e \`a d'\'eventuelles incompatibilit\'es dans les prochaines versions de \LaTeX{}.

\subsubsection{Faire dans le portable}

Il est \'egalement raisonnable de rendre vos fichiers le plus portable possible. 
Afin d'assurer cela, ils ne devraient contenir que du texte 7 bits visible et 
porter un nom d'au plus huit caract\`eres (plus les trois lettres de 
l'extension).  De plus, ils \textbf{ne doivent} bien s\^ur \textbf{pas} avoir le 
m\^eme nom qu'un fichier de la distribution standard \LaTeX{}, m\^eme si son 
contenu peut \^etre  tout \`a fait similaire.

Il est \'egalement utile que les  classes ou packages locaux  aient un pr\'efixe 
commun; par exemple, ceux de l'Universit\'e de Nulle Part pourraient commencer 
par |unp|. Ceci aide \`a \'eviter que si chaque Universit\'e a sa propre classe 
de th\`ese, toutes soient appel\'ees |thesis.cls|.
 
Si vous comptez sur certaines fonctions du noyau \LaTeX{}, ou sur un package, 
veuillez sp\'ecifier la version-date dont vous avez besoin. Par exemple, les 
commandes d'erreur pour package ont \'et\'e introduites dans la version de juin 
1994~; donc, si vous les employez, vous devriez sp\'ecifier:
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}[1994/06/01]
\end{verbatim}

\subsubsection{Points d'entr\'ee utiles}

Certains packages et styles de document devaient red\'efinir les commandes 
|\document| ou |\enddocument| pour parvenir \`a leurs fins.  Ce n'est plus 
n\'ecessaire. Vous pouvez d\'esormais utiliser les <<~points d'entr\'ee~>> |\AtBeginDocument| et 
|\AtEndDocument| (voir la section~\ref{Sec:delays}). Une fois encore, 
l'utilisation de ces points d'entr\'ee rend improbable les ruptures avec les futures 
versions de \LaTeX{}. Elle rend \'egalement plus probable le fonctionnement 
de votre package avec celui de quelqu'un d'autre.

\NEWdescription{1996/12/01}
Cependant, notez que le code dans le point d'entr\'ee |\AtBeginDocument| appartient au 
pr\'eambule du document. Il y a ainsi des restrictions sur ce qui peut y \^etre mis~; 
en particulier, aucune composition ne peut y \^etre faite.

\section{La structure d'une classe ou package}
\label{Sec:structure}
 
Les classes et packages \LaTeXe{}  ont plus de structure que les fichiers de 
style \LaTeX~2.09
n'en avaient.  L'esquisse d'une classe ou d'un package est la suivante~:
\begin{description}
   \item[Identification] Le fichier dit qu'il est un package ou une
   classe \LaTeXe{}, et donne une courte description de lui-m\^eme.
   \item[D\'eclarations pr\'eliminaires]
   Ici, le fichier d\'eclare quelques commandes et peut \'egalement charger d'autres 
   fichiers. Habituellement, ces commandes seront juste celles requises pour le 
   code utilis\'e dans les options d\'eclar\'ees.
   \item[Options] Le fichier d\'eclare et traite ses options.
   \item[D'autres d\'eclarations] C'est l'endroit o\`u le fichier accomplit  le gros 
   de son travail:
   d\'eclaration de nouvelles variables, commandes et fontes, et chargement d'autres fichiers.
\end{description}
 
\subsection{Identification}
 
La premi\`ere chose qu'une classe ou qu'un package fait est de s'identifier lui-m\^eme.
Les fichiers de package le font de la mani\`ere suivante:
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}
   \ProvidesPackage{<package>}[<date> <autre information>]
\end{verbatim}
Par exemple:
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}
   \ProvidesPackage{latexsym}[1994/06/01 Standard LaTeX package]
\end{verbatim}
Les fichiers de classes le font quant  \`a eux ainsi:
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}
   \ProvidesClass{<nom-classe>}[<date> <autre information>]
\end{verbatim}
Par exemple:
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}
   \ProvidesClass{article}[1994/06/01 Standard LaTeX class]
\end{verbatim}
\NEWdescription{1998/06/19}
La \m{date} devrait \^etre donn\'ee sous la forme <<~\textsc{yyyy/mm/dd}~>> et
doit \^etre pr\'esente si l'argument optionnel est utilis\'e (ceci est \'egalement vrai
pour la commande |\NeedsTeXFormat|). 

Tout \'ecart par rapport \`a cette syntaxe r\'esultera en des erreurs \TeX{} de bas 
niveau --- les commandes s'attendent \`a une syntaxe valide pour acc\'el\'erer 
l'utilisation quotidienne du package ou de la classe et ne pr\'evoit pas le cas 
o\`u le d\'eveloppeur a commis une erreur!

La date est v\'erifi\'ee chaque fois que l'utilisateur la sp\'ecifie dans la commande
|\documentclass| ou |\usepackage|.  Par exemple, si vous \'ecriviez:
\begin{verbatim}
   \documentclass{article}[1995/12/23]
\end{verbatim}
alors les utilisateurs \`a diff\'erents endroits obtiendraient un avertissement leur 
signalant que leur copie d'|article| est obsol\`ete.
 
La description d'une classe est affich\'ee quand la classe est utilis\'ee.  La 
description d'un package est ins\'er\'ee dans le fichier log. Ces descriptions 
sont \'egalement affich\'ees par la commande |\listfiles|.  L'expression 
\texttt{Standard LaTeX} \textbf{ne doit pas} \^etre utilis\'ee dans la banni\`ere 
d'identification d'un fichier autre que ceux de la distribution standard \LaTeX{}.

 
\subsection{Utilisation des classes et packages}
 
La premi\`ere diff\'erence importante entre les fichiers de style \LaTeX~2.09 et les 
packages et classes de \LaTeXe{} est que \LaTeXe{} g\`ere la \emph{modularit\'e}, au 
sens o\`u il peut construire des fichiers \`a partir de petits blocs de construction 
plut\^ot qu'\`a partir d'un seul grand fichier.

Un package ou classe \LaTeX{} peut charger un package comme suit:
\begin{verbatim}
   \RequirePackage[<options>]{<package>}[<date>]
\end{verbatim}
Par exemple:
\begin{verbatim}
   \RequirePackage{ifthen}[1994/06/01]
\end{verbatim}
Cette commande a la m\^eme  syntaxe que la commande d'auteur |\usepackage|.
Elle permet aux packages ou aux classes d'utiliser les fonctions d'autres
packages.  Par exemple, en chargeant le package |ifthen|, l'auteur d'un package
peut utiliser les commandes <<~if\dots then\dots else\dots~>> fournies par ce
package.
 
Une classe \LaTeX{} peut charger une autre classe comme suit:
\begin{verbatim}
   \LoadClass[<options>]{<om-classe>}[<date>]
\end{verbatim}
Par exemple:
\begin{verbatim}
   \LoadClass[twocolumn]{article}
\end{verbatim}
Cette commande a la m\^eme  syntaxe que la commande d'auteur |\documentclass|. 
Elle permet aux classes d'\^etre bas\'ees sur la syntaxe et  l'apparence d'une 
autre classe.   Par exemple, en chargeant la classe |article|, l'auteur d'un 
package a seulement \`a changer les parties d'|article| qu'il n'aime pas, plut\^ot que 
de partir de z\'ero.

\NEWfeature{1995/12/01}
Les commandes suivantes peuvent \^etre utilis\'ees dans le cas classique o\`u vous 
voulez simplement charger une classe ou un package avec exactement les m\^emes options 
que celles utilis\'ees par la classe courante.
\begin{verbatim}
   \LoadClassWithOptions{<nom-classe>}[<date>]
   \RequirePackageWithOptions{<package>}[<date>]
\end{verbatim}
Par exemple:
\begin{verbatim}
   \LoadClassWithOptions{article}
   \RequirePackageWithOptions{graphics}[1995/12/01]
\end{verbatim}

\subsection{D\'eclaration d'options}
 
\NEWdescription{1998/12/01}
L'autre importante diff\'erence entre les styles \LaTeX~2.09 et les packages et 
classes \LaTeXe{} est dans la manipulation des options.  Les packages et classes 
peuvent \`a pr\'esent d\'eclarer des options~; celles-ci peuvent \^etre sp\'ecifi\'ees par les 
auteurs. Par exemple, l'option |twocolumn| est d\'eclar\'ee par la classe |article|. 
Notez que le nom d'une option ne devrait contenir que les caract\`eres autoris\'es
dans un  <<~nom \LaTeX{}~>>; en particulier, il ne doit pas contenir  de s\'equences contr\^ole.

Une option est d\'eclar\'ee comme suit:
\begin{verbatim}
   \DeclareOption{<option>}{<code>}
\end{verbatim}
Par exemple, l'option |dvips|  (l\'eg\`erement simplifi\'ee)
du package  |graphics| est impl\'ement\'ee comme ceci:
\begin{verbatim}
   \DeclareOption{dvips}{\input{dvips.def}}
\end{verbatim}
Cela signifie que quand un auteur \'ecrit |\usepackage[dvips]{graphics}|,
le fichier |dvips.def| est charg\'e.  Un autre exemple~: l'option |a4paper|
est d\'eclar\'ee dans la classe |article| afin de fixer les longueurs |\paperheight|
et |\paperwidth|~:
\begin{verbatim}
   \DeclareOption{a4paper}{%
      \setlength{\paperheight}{297mm}%
      \setlength{\paperwidth}{210mm}%
   }
\end{verbatim}
Parfois, un utilisateur appellera une option que la classe ou le package n'a pas 
explicitement d\'eclar\'ee. Par d\'efaut, ceci produira un avertissement (pour les 
classes) ou une erreur (pour les packages); ce comportement peut \^etre chang\'e comme suit~:
\begin{verbatim}
   \DeclareOption*{<code>}
\end{verbatim}
Par exemple, pour que le package |fred| produise un avertissement plut\^ot qu'une 
erreur pour les options inconnues, vous pouvez sp\'ecifier~:
\begin{verbatim}
   \DeclareOption*{%
      \PackageWarning{fred}{Option inconnue `\CurrentOption'}%
   }
\end{verbatim}
Ainsi, si un auteur \'ecrit |\usepackage[foo]{fred}|, il obtiendra l'avertissement 
\texttt{Package fred Warning: Option inconnue `foo'.}  Autre exemple~: le package 
|fontenc| essaie de charger un fichier |<ENC>enc.def| lorsque l'option \m{ENC} 
est utilis\'ee.  Ceci peut \^etre fait en \'ecrivant~:
\begin{verbatim}
   \DeclareOption*{%
      \input{\CurrentOption enc.def}%
   }
\end{verbatim}
\NEWdescription{1998/12/01}
Il est  possible de passer des options \`a un autre package ou classe, en 
utilisant la commande |\PassOptionsToPackage| ou |\PassOptionsToClass| (notez 
que ce sont des op\'erations sp\'ecialis\'ees qui ne marchent que pour les noms 
d'options).  Par exemple, pour passer toutes les options inconnues \`a la classe 
|article|, vous pouvez utiliser:
\begin{verbatim}
   \DeclareOption*{%
      \PassOptionsToClass{\CurrentOption}{article}%
   }
\end{verbatim}
Si vous faites ceci, il faut alors vous assurer que vous chargez la classe \`a un 
moment ou \`a un autre, plus tard, sinon les options ne seront jamais trait\'ees! 
 
Jusqu'\`a pr\'esent, nous avons expliqu\'e comment d\'eclarer des options, et non 
comment les ex\'ecuter. Pour traiter les options avec lesquelles le fichier a \'et\'e 
appel\'e, vous devez utiliser~:
\begin{verbatim}
   \ProcessOptions\relax
\end{verbatim}
Ceci ex\'ecute le \m{code} pour chacune des options qui ont \'et\'e \`a la fois 
sp\'ecifi\'ees et d\'eclar\'ees (voir la section~\ref{Sec:commandes.options} pour 
les d\'etails sur comment ceci est fait).
 
Par exemple, si le fichier du package |jane| contient~:
\begin{verbatim}
   \DeclareOption{foo}{\typeout{Saw foo.}}
   \DeclareOption{baz}{\typeout{Saw baz.}}
   \DeclareOption*{\typeout{What's \CurrentOption?}}
   \ProcessOptions\relax
\end{verbatim}
et si un auteur \'ecrit |\usepackage[foo,bar]{jane}|, il verra alors les messages 
\texttt{Saw foo.} et \texttt{What's baz?}
 
\subsection{Un fichier de classe minimal}
 
Le gros de la tâche d'une classe ou d'un package est de d\'efinir de nouvelles 
commandes, ou de changer l'apparence de documents.  Ceci est fait dans le corps 
du package, en utilisant des commandes telles que |\newcommand| ou |\setlength|.

\LaTeXe{} fournit plusieurs nouvelles commandes pour aider les auteurs de 
classes et de packages~; celles-ci sont d\'ecrites en d\'etail dans la 
section~\ref{Sec:commandes}.
 
Il y a trois choses que tout fichier de classe \emph{doit} contenir~:
une d\'efinition de |\normalsize| et des valeurs de |\textwidth|
et |\textheight|.  Un fichier de classe minimal\footnote
{Cette classe est maintenant dans la distribution standard, 
 sous le nom \texttt{minimal.cls}.} ressemble donc \`a cela~:
\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}
\end{verbatim}
Cependant, ce fichier de classe ne g\`erera pas les notes de pied de page, les 
marges, les flottants, etc., et ne fournira pas non plus les commandes de fontes 
de 2 lettres telles que |\rm|~; ainsi, la plupart des classes contiendront un 
petit peu plus que ce minimum!
 
\subsection{Exemple~: une classe locale de lettre}
 
Une entreprise peut avoir sa propre classe de lettre pour composer des lettres 
au style de l'entreprise. Cette section montre une simple impl\'ementation d'une 
telle classe, bien qu'une vraie classe n\'ecessiterait plus de structure.

Cette classe commence par s'annoncer comme \'etant le fichier |neplet.cls|.
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}
   \ProvidesClass{neplet}[1995/04/01 NonExistent Press letter class]
\end{verbatim}
Ensuite, la partie suivante passe n'importe quelle option \`a la classe |letter|, qui
est charg\'ee avec l'option |a4paper|.
\begin{verbatim}
   \DeclareOption*{\PassOptionsToClass{\CurrentOption}{letter}}
   \ProcessOptions\relax
   \LoadClass[a4paper]{letter}
\end{verbatim}
Afin d'utiliser l'ent\^ete de l'entreprise, la classe red\'efinit le style de la page
|firstpage|~: c'est le style de page utilis\'e sur la premi\`ere page des lettres.
\begin{verbatim}
   \renewcommand{\ps@firstpage}{%
      \renewcommand{\@oddhead}{<l'en-tête de la lettre va ici>}%
      \renewcommand{\@oddfoot}{<le pied de page de la lettre va ici>}%
   }
\end{verbatim}
Et voil\`a!
 
\subsection{Exemple~: une classe lettre d'information}
 
Une simple lettre d'information peut \^etre compos\'ee avec \LaTeX{}, en utilisant une variante
de la classe |article|.
La classe commence par s'annoncer comme \'etant le fichier |smplnews.cls|.
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}
   \ProvidesClass{smplnews}[1995/04/01 The Simple News newsletter class]

   \newcommand{\headlinecolor}{\normalcolor}
\end{verbatim}
Elle passe la plupart des options sp\'ecifi\'ees \`a la classe |article|, sauf 
l'option |onecolumn|, qui est d\'esactiv\'ee et l'option |green| qui met le titre en vert.
\begin{verbatim}
   \DeclareOption{onecolumn}{\OptionNotUsed}
   \DeclareOption{green}{\renewcommand{\headlinecolor}{\color{green}}}

   \DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}

   \ProcessOptions\relax
\end{verbatim}
Elle charge alors la classe |article| avec l'option |twocolumn|.
\begin{verbatim}
   \LoadClass[twocolumn]{article}
\end{verbatim}
\'Etant donn\'e que la lettre d'information sera imprim\'ee en couleur, elle charge 
\`a pr\'esent le package |color|.  La classe ne sp\'ecifie pas l'option du pilote car 
cela sera pr\'ecis\'e par l'utilisateur de la classe |smplnews|.
\begin{verbatim}
   \RequirePackage{color}
\end{verbatim}
La classe red\'efinit alors |\maketitle| pour produire un titre en 72 pt
Helvetica gras oblique, dans la couleur appropri\'ee.
\begin{verbatim}
   \renewcommand{\maketitle}{%
      \twocolumn[%
         \fontsize{72}{80}\fontfamily{phv}\fontseries{b}%
         \fontshape{sl}\selectfont\headlinecolor
         \@title
      ]%
   }
\end{verbatim}
Elle red\'efinit |\section| et d\'esactive la num\'erotation des sections.
\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}
Elle fixe \'egalement trois choses importantes.
\begin{verbatim}
   \renewcommand{\normalsize}{\fontsize{9}{10}\selectfont}
   \setlength{\textwidth}{17.5cm}
   \setlength{\textheight}{25cm}
\end{verbatim}
En pratique, une classe n\'ecessiterait plus que cela: elle fournirait des 
commandes pour le num\'ero de la lettre, les auteurs des articles, les styles de 
page, etc. Toutefois, ce squelette donne un d\'ebut. Le fichier de la classe 
|ltnews| n'est pas beaucoup plus compliqu\'e que celui-ci.
 
\section{Commandes pour les auteurs de classes et packages}
\label{Sec:commandes}
 
Cette section d\'ecrit bri\`evement chacune des nouvelles commandes pour les auteurs 
de classes et de packages. Pour vous renseigner sur les autres aspects du 
nouveau syst\`eme, vous devriez lire \'egalement \emph{\LaTeXbook}, 
\emph{\LaTeXcomp} et \emph{\usrguide}.
 
\subsection{Identification}
 
Le premier groupe de commandes discut\'e ici est celui utilis\'e pour
identifier votre fichier de classe ou de package.
 
\begin{decl}
|\NeedsTeXFormat| \arg{nom-format} \oarg{date-emission}
\end{decl}
Cette commande indique \`a \TeX{} que ce fichier doit \^etre trait\'e en utilisant un 
format du nom \m{nom-format}.  Vous pouvez utiliser l'argument optionnel 
\m{date-emission} pour indiquer la date d'\'emission du format le plus ancien
requis.  Quand la date de r\'ealisation du format est post\'erieure \`a celle 
sp\'ecifi\'ee, un avertissement est produit. Le \m{nom-format} standard est 
\texttt{LaTeX2e}.  La date, si elle est pr\'esente, doit \^etre mise sous la forme 
\textsc{yyyy/mm/dd}.
 
Exemple:
\begin{verbatim}
   \NeedsTeXFormat{LaTeX2e}[1994/06/01]
\end{verbatim}
 
\begin{decl}
|\ProvidesClass| \arg{nom-classe} \oarg{info-version} \\
|\ProvidesPackage| \arg{nom-packge} \oarg{info-version}
\end{decl}
Ceci d\'eclare que le fichier actuel contient les d\'efinitions pour la classe de 
document \m{nom-classe} ou le package \m{nom-package}.

L'optionnelle \m{info-version}, si elle est utilis\'ee, doit contenir:
\begin{itemize}
  \item la date de r\'ealisation de
  la version de ce fichier, sous la forme \textsc{yyyy/mm/dd};
  \item suivie de mani\`ere optionnelle par une espace et une courte description, 
  qui peut inclure \'eventuellement un num\'ero de version.
\end{itemize}
La syntaxe ci-dessus doit \^etre suivie scrupuleusement afin que cette information 
puisse \^etre utilis\'ee par  |\LoadClass| ou |\documentclass| (pour les classes), 
ou |\RequirePackage| ou |\usepackage| (pour les packages) pour v\'erifier que la 
version n'est pas trop ancienne.

L'information \m{info-version} enti\`ere est affich\'ee par
|\listfiles| et ne doit pas, par cons\'equent, \^etre trop longue.
 
exemple:
\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{nom-fichier} \oarg{info-version}
\end{decl}
Ceci est similaire aux deux commandes pr\'ec\'edentes, sauf qu'ici, le nom complet, 
y compris l'extension doit \^etre donn\'e. Cette commande est utilis\'ee pour la 
d\'eclaration de fichiers autres que les fichiers de classe et package principaux.

Exemple:
\begin{verbatim}
   \ProvidesFile{T1enc.def}[1994/06/01 v1.0 Standard LaTeX file]
\end{verbatim}
 
Notez que l'expression \texttt{Standard LaTeX} \textbf{ne doit pas} \^etre utilis\'ee 
dans la banni\`ere d'identification d'un fichier autre que ceux de la distribution 
standard \LaTeX{}.

\subsection{Chargement de fichiers}
\label{Sec:loadf}

\NEWfeature{1995/12/01}
Ce groupe de commandes peut \^etre utilis\'e pour cr\'eer votre classe de document ou 
package en le construisant sur des classes ou packages d\'ej\`a existants.
\begin{decl}
  |\RequirePackage| \oarg{liste-options} \arg{nom-package}
     \oarg{info-version}\\
  |\RequirePackageWithOptions| \arg{nom-package}
     \oarg{info-version}
\end{decl}
Les packages et classes devraient utiliser ces commandes pour charger d'autres packages.

L'utilisation de |\RequirePackage| est la m\^eme que la commande d'auteur
|\usepackage|.
 
Exemples:
\begin{verbatim}
   \RequirePackage{ifthen}[1994/06/01]
   \RequirePackageWithOptions{graphics}[1995/12/01]
\end{verbatim}
 
\begin{decl}
  |\LoadClass| \oarg{liste-options} \arg{nom-classe}
     \oarg{info-version}\\
  |\LoadClassWithOptions| \arg{nom-classe}
     \oarg{info-version}
\end{decl}
\NEWfeature{1995/12/01}
Ces commandes ne doivent \^etre utilis\'ees \emph{que} dans des fichiers de classe, 
et ne peuvent figurer dans des fichiers de packages;
elles peuvent \^etre utilis\'ees au plus une fois dans un fichier de classe.
 
L'utilisation de |\LoadClass| est la m\^eme que celle de |\documentclass| pour 
charger un fichier de classe.

Exemples:
\begin{verbatim}
   \LoadClass{article}[1994/06/01]
   \LoadClassWithOptions{article}[1995/12/01]
\end{verbatim}

\NEWfeature{1995/12/01}
Les deux versions |WithOptions|  chargent simplement le fichier de la  classe 
(ou du package) avec exactement les m\^emes options que celles utilis\'ees par le 
fichier courant (classe ou package). Voir plus loin, \`a la section \ref{Sec:opmove}, pour 
une discussion plus pr\'ecise quant \`a leur utilisation.


\subsection{D\'eclaration d'option}
\label{Sec:commandes.options.dec}

\NEWdescription{1998/12/01}
Les commandes suivantes se chargent de la d\'eclaration et de la manipulation
des options pass\'ees aux classes de document et aux packages.  Chaque option doit porter un
<<~nom \LaTeX{}~>>.

Il existe quelques commandes con\c{c}ues sp\'ecialement pour \^etre utilis\'ees \`a l'int\'erieur de l'argument
\m{code} de ces commandes (voir ci-dessous).

\begin{decl}
  |\DeclareOption| \arg{nom-option} \arg{code}
\end{decl}
Cette commande fait de \m{nom-option} une <<~option d\'eclar\'ee~>> de la classe ou du package
dans laquelle elle est ins\'er\'ee.

L'argument \m{code}  contient le code \`a ex\'ecuter si cette option est sp\'ecifi\'ee pour la classe 
ou le package; il peut contenir n'importe quelle construction valide \LaTeXe{}.

Exemple:
\begin{verbatim}
   \DeclareOption{twoside}{\@twosidetrue}
\end{verbatim}
 
\begin{decl}
  |\DeclareOption*| \arg{code}
\end{decl}
Ceci d\'eclare le \m{code} \`a ex\'ecuter pour chaque option sp\'ecifi\'ee, mais non explicitement 
d\'eclar\'ee par ailleurs par la classe ou le package; ce code est appel\'e le <<~code d'option par d\'efaut~>> 
et peut contenir n'importe quelle construction valide de \LaTeXe{}.

Si le fichier d'une classe ne contient aucun |\DeclareOption*| alors, par d\'efaut, toutes
les options sp\'ecifi\'ees mais non d\'eclar\'ees pour cette classe seront de mani\`ere silencieuse
pass\'ees \`a tous les packages (comme le seront les options sp\'ecifi\'ees et d\'eclar\'ees pour cette
classe).

Si un fichier de package ne contient aucun |\DeclareOption*| alors, par d\'efault, chaque
option sp\'ecifi\'ee mais non d\'eclar\'ee pour ce package produira une erreur.


\subsection{Commandes \`a l'int\'erieur du code d'option}
\label{Sec:within.code}

Ces  deux commandes ne peuvent \^etre utilis\'ees qu'\`a l'int\'erieur de l'argument \m{code} de  |\DeclareOption| 
ou |\DeclareOption*|.  Les autres  commandes commun\'ement
utilis\'ees \`a l'int\'erieur de ces arguments peuvent \^etre trouv\'ees dans les prochaines sous-sections.

\begin{decl}
  |\CurrentOption|
\end{decl}
Ceci sera remplac\'e le nom de l'option courante.
 
\begin{decl}
  |\OptionNotUsed|
\end{decl}
Ceci fait que l'option courante est ajout\'ee \`a la liste des <<~options inutilis\'ees~>>.

\NEWfeature{1995/06/01}
  Vous pouvez d\'esormais inclure des di\`eses (\texttt{\#}) \`a l'int\'erieur de ces arguments \m{code}
   sans traitement sp\'ecial (auparavant, il \'etait n\'ecessaire de les doubler).

\subsection{Promener des options}
\label{Sec:opmove} 

Ces deux commandes sont \'egalement tr\`es utiles \`a l'int\'erieur de l'argument \m{code} 
de |\DeclareOption| ou |\DeclareOption*|:
\begin{decl}
  |\PassOptionsToPackage| \arg{liste-options} \arg{nom-package}\\
  |\PassOptionsToClass| \arg{liste-options} \arg{nom-classe}
\end{decl}
La commande |\PassOptionsToPackage| passe les noms d'option dans la
\m{liste-options} au package \m{nom-package}.
Cela signifie que la \m{liste-options} est ajout\'ee
\`a la liste d'options utilis\'ees par une \'eventuelle commande |\RequirePackage| or |\usepackage|
 pour le package \m{nom-package}.
 
Exemple:
\begin{verbatim}
   \PassOptionsToPackage{foo,bar}{fred}
   \RequirePackage[baz]{fred}
\end{verbatim}
est la m\^eme chose que~:
\begin{verbatim}
   \RequirePackage[foo,bar,baz]{fred}
\end{verbatim}

De la m\^eme mani\`ere, |\PassOptionsToClass| peut \^etre utilis\'e dans un fichier de classe pour
passer des options \`a une autre classe charg\'ee avec |\LoadClass|.
 
\NEWdescription{1995/12/01}
Les effets et l'utilisation de ces deux commandes doivent \^etre mis en contraste avec
ceux des deux suivantes (document\'ees ci-dessus, au \ref{Sec:loadf})~:
\begin{verbatim}
   \LoadClassWithOptions
   \RequirePackageWithOptions
\end{verbatim}
La commande |\RequirePackageWithOptions| est similaire \`a
|\RequirePackage|, mais elle charge toujours le package requis 
avec exactement la m\^eme liste d'options que celle utilis\'ee par la 
classe ou package courant plut\^ot qu'avec n'importe qu'elle option 
fournie ou pass\'ee par |\PassOptionsToPackage|.

Le but principal de |\LoadClassWithOptions| est de permettre \`a une 
classe d'\^etre construite sur une autre. Par exemple~:
\begin{verbatim}
  \LoadClassWithOptions{article}
\end{verbatim}
\`A comparer avec la construction l\'eg\`erement diff\'erente~:
\begin{verbatim}
  \DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
  \ProcessOptions\relax
  \LoadClass{article}
\end{verbatim}
Utilis\'ee comme ci-dessus, les effets sont plus ou moins les m\^emes, 
mais la premi\`ere construction est tout de m\^eme moins longue \`a taper~;
de plus, la m\'ethode utilisant |\LoadClassWithOptions| s'ex\'ecute l\'eg\`erement
plus vite.

Si, cependant, la classe d\'eclare ses propres options, les deux constructions
sont alors diff\'erentes. Comparez, par exemple~:
\begin{verbatim}
  \DeclareOption{landscape}{\@landscapetrue}
  \ProcessOptions\relax
  \LoadClassWithOptions{article}
\end{verbatim}
avec~:
\begin{verbatim}
  \DeclareOption{landscape}{\@landscapetrue}
  \DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
  \ProcessOptions\relax
  \LoadClass{article}
\end{verbatim}
Dans le premier exemple, la classe \textsf{article} sera charg\'ee avec
l'option |landscape| pr\'ecis\'ement quand la classe courante sera appel\'ee 
avec cette option. \`A l'oppos\'e, dans le second exemple, elle ne sera jamais
appel\'ee avec l'option \texttt{landscape}, \'etant donn\'e que dans ce cas, les options
sont pass\'ees \`a \textsf{article} seulement par le manipulateur d'option par d\'efaut.
Or, ce manipulateur n'est pas utilis\'e pour |landscape| car cette option est explicitement
d\'eclar\'ee.

\subsection{Diff\'erer}
\label{Sec:delays}

Ces deux premi\`eres commandes sont \'egalement essentiellement destin\'ees \`a \^etre
utilis\'ees \`a l'int\'erieur de l'argument \m{code} de |\DeclareOption| ou |\DeclareOption*|.

\begin{decl}
  |\AtEndOfClass| \arg{code}\\
  |\AtEndOfPackage| \arg{code}
\end{decl}
Ces commandes d\'eclarent \m{code} qui est m\'emoris\'e de mani\`ere interne
et ensuite ex\'ecut\'e apr\`es le traitement du fichier de la classe ou package
entier.
 
L'utilisation r\'eit\'er\'ee de ces commandes est autoris\'ee~: le code de leurs
arguments est sauv\'e (et ex\'ecut\'e plus tard) dans l'ordre de leurs 
d\'eclarations.
 
\begin{decl}
  |\AtBeginDocument| \arg{code}\\
  |\AtEndDocument| \arg{code}
\end{decl}
Ces commandes d\'eclarent \m{code} qui est m\'emoris\'e de mani\`ere interne
et ensuite ex\'ecut\'e
lorsque \LaTeX{} ex\'ecute |\begin{document}| ou |\end{document}|.
 
Le \m{code} sp\'ecifi\'e dans  l'argument de |\AtBeginDocument| est 
ex\'ecut\'e proche de la fin du code de |\begin{document}|, \emph{apr\`es} l'installation
des tables de s\'election de fontes. Cela reste par cons\'equent un endroit
int\'eressant pour mettre du code qui doit \^etre ex\'ecut\'e apr\`es que tout a \'et\'e
pr\'epar\'e pour la composition et lorsque le fonte courante est la fonte 
normale appliqu\'ee \`a tout le document. 


\NEWdescription{1995/12/01}
Le point d'entr\'ee |\AtBeginDocument| ne doit pas \^etre utilis\'e pour du code
r\'ealisant une composition, car le r\'esultat est assez impr\'evisible.

Le \m{code} sp\'ecifi\'e dans l'argument de |\AtEndDocument| est ex\'ecut\'e au d\'ebut
du code de |\end{document}|,
\emph{avant} que la page finale ne soit termin\'ee et avant que les environnements
flottants restants ne soient trait\'es. Si une partie du \m{code} doit \^etre
ex\'ecut\'ee apr\`es ces deux traitements, vous devriez inclure un |\clearpage|
\`a un endroit appropri\'e de \m{code}.
 
L'utilisation r\'eit\'er\'ee de ces commandes est autoris\'ee~: le code de leurs
arguments est sauv\'e (et ex\'ecut\'e plus tard) dans l'ordre de leurs 
d\'eclarations.
 
\begin{decl}[1994/12/01]
  |\AtBeginDvi| \arg{specials}
\end{decl}
Cette commande sauve dans un registre de boîte des choses \`a \'ecrire dans
le fichier |.dvi| au d\'ebut du <<~shipout~>> de la premi\`ere page du
document.

Elle ne devrait pas \^etre utilis\'ee pour quelque chose qui ajouterait
des \'el\'ements de composition dans le fichier |.dvi|.
 
L'utilisation r\'eit\'er\'ee de cette commande est autoris\'ee.
 

\subsection{Traitement d'options}
\label{Sec:commandes.options}
 
\begin{decl}
  |\ProcessOptions|
\end{decl}
Cette commande ex\'ecute \m{code} pour chaque option s\'electionn\'ee.
 
Nous allons d'abord d\'ecrire comment |\ProcessOptions| marche dans le fichier d'un package,
et ensuite expliquer en quoi cela diff\`ere dans un fichier de classe.
 
Pour comprendre dans le d\'etail ce que |\ProcessOptions| fait dans le fichier d'un package,
vous devez conna\^itre la diff\'erence entre les options \emph{locales} et \emph{globales}.

\begin{itemize}
\item \textbf{Les options locales} sont celles qui ont \'et\'e expicitement
  sp\'ecifi\'ees pour ce package particulier dans l'argument \m{options} de~:
\begin{quote}
    |\PassOptionsToPackage{<options>}| \ |\usepackage[<options>]|\\
    |\RequirePackage[<options>]|
\end{quote}
\item \textbf{Les options globales} sont toutes les autres options d\'eclar\'ees par l'auteur 
dans l'argument \m{options} de
    |\documentclass[<options>]|.
\end{itemize}
Par exemple, supposons qu'un document commence par~:
\begin{verbatim}
   \documentclass[german,twocolumn]{article}
   \usepackage{gerhardt}
\end{verbatim}
alors que le package |gerhardt| appelle le package |fred| avec~:
\begin{verbatim}
   \PassOptionsToPackage{german,dvips,a4paper}{fred}
   \RequirePackage[errorshow]{fred}
\end{verbatim}
alors~:
\begin{itemize}
\item  les options locales de |fred| sont |german|, |dvips|, |a4paper|
  et |errorshow|~;
\item la seule option globale de |fred| est |twocolumn|.
\end{itemize}

Quand |\ProcessOptions| est appel\'e, il se produit les choses suivantes.
\begin{itemize}
\item \emph{D'abord}, pour chaque option d\'eclar\'ee jusqu'alors dans |fred.sty|
  par |\DeclareOption|, il faut d\'eterminer si cette option est une option
  globale ou locale pour |fred|~: le code est alors ex\'ecut\'e selon le cas.

  Ceci se fait dans l'ordre de d\'eclaration de ces options
  dans |fred.sty|.
\item \emph{Ensuite}, pour chaque option \emph{locale} restante, la commande
  |\ds@<option>| est ex\'ecut\'ee si elle a \'et\'e d\'efinie quelque part 
  (ailleurs que dans un |\DeclareOption|)~; sinon, le <<~code de l'option par
  d\'efaut~>> est ex\'ecut\'e. Si aucun code d'option par d\'efaut n'a \'et\'e d\'eclar\'e, un message 
  d'erreur est retourn\'e.

  Ceci se fait dans l'ordre dans lequel les options ont \'et\'e sp\'ecifi\'ees.
\end{itemize}
Durant tout ce processus, le syst\`eme s'assure que le code d\'eclar\'e pour une
option est ex\'ecut\'e au plus une fois.

Revenons \`a notre exemple. Si |fred.sty| contient~:
\begin{verbatim}
   \DeclareOption{dvips}{\typeout{DVIPS}}
   \DeclareOption{german}{\typeout{GERMAN}}
   \DeclareOption{french}{\typeout{FRENCH}}
   \DeclareOption*{\PackageWarning{fred}{Unknown `\CurrentOption'}}
   \ProcessOptions\relax
\end{verbatim}
alors le r\'esultat du traitement de ce document sera~:
\begin{verbatim}
   DVIPS
   GERMAN
   Package fred Warning: Unknown `a4paper'.
   Package fred Warning: Unknown `errorshow'.
\end{verbatim}
Notez que~:

\begin{itemize}
\item le code pour l'option |dvips| est ex\'ecut\'e avant celui de l'option 
  |german|, car c'est l'ordre dans lequel elles sont d\'eclar\'ees dans
  |fred.sty|~;
\item le code pour l'option |german| est ex\'ecut\'e seulement une fois, quand
les options d\'eclar\'ees sont trait\'ees~;
\item les options |a4paper| et |errorshow| produisent l'avertissement du
  code d\'eclar\'e par |\DeclareOption*| (dans l'ordre dans lequel elles 
  ont \'et\'e sp\'ecifi\'ees), alors que ce n'est pas le cas pour l'option |twocolumn|, ceci
  parce que |twocolumn| est une option globale.
\end{itemize}
 
Dans une classe, |\ProcessOptions| fonctionne de la m\^eme fa\c{c}on, sauf que
\emph{toutes} les options sont locales~; la valeur par d\'efaut de
|\DeclareOption*| est alors |\OptionNotUsed| plut\^ot qu'une erreur.

\NEWdescription{1995/12/01}
Notez que, du fait que |\ProcessOptions| ait une forme |*|, il est sage de
faire suivre la forme non-\'etoil\'ee par un |\relax|, comme dans les exemples pr\'ec\'edents,
afin d'emp\^echer les inutiles poursuites de lecture de code et les potentiels messages 
induisant en erreur.

\begin{decl}
  |\ProcessOptions*|
  |\@options|
\end{decl}
Cette commande ressemble \`a |\ProcessOptions| mais elle ex\'ecute les options dans
l'ordre sp\'ecifi\'e par les commandes appelantes, plut\^ot que dans l'ordre de leur
d\'eclaration dans la classe ou package. Pour un package, cela veut dire
que les options globales sont trait\'ees d'abord.

La macro |\@options| de \LaTeX~2.09 a \'et\'e rendue \'equivalente \`a cette 
commande afin de faciliter les remises \`a jour des anciens styles de 
 document en fichier de classe \LaTeXe{}.

\begin{decl}
  |\ExecuteOptions| \arg{liste-options}
\end{decl}

Pour chaque option de \m{liste-options}, 
cette commande ex\'ecute simplement, dans l'ordre, la commande 
|\ds@<option>| (si cette commande n'est pas d\'efinie, alors cette
option est ignor\'ee silencieusement).

Elle peut \^etre utilis\'ee pour fournir une <<~liste d'options par d\'efaut~>>
juste avant
|\ProcessOptions|. Supposons, par exemple, que dans un fichier de classe, vous 
souhaitez que la composition par d\'efaut soit~: impression recto-verso~; fontes 11~pt~;
sur deux colonnes. Alors cette commande pourra sp\'ecifier~:
\begin{verbatim}
   \ExecuteOptions{11pt,twoside,twocolumn}
\end{verbatim}


\subsection{Commandes s\^ures pour les fichiers}
 
Ces commandes s'occupent de l'insertion de fichiers~; elles assurent que la
non-existence d'un fichier appel\'e sera trait\'e de mani\`ere conviviale\ldots
 
\begin{decl}
|\IfFileExists| \arg{nom-fichier} \arg{vrai} \arg{faux}
\end{decl}
Si le fichier existe, alors le code pr\'ecis\'e dans \m{vrai} est
ex\'ecut\'e.
 
S'il n'existe pas, alors le code dans \m{faux} est ex\'ecut\'e.
 

Cette commande \emph{n'ins\`ere pas} le fichier.

\begin{decl}
  |\InputIfFileExists| \arg{nom-fichier} \arg{vrai} \arg{faux}
\end{decl}
Cette commande ins\`ere le fichier \m{nom-fichier} s'il existe et imm\'ediatement 
avant l'insertion, le code dans \m{vrai} est ex\'ecut\'e.

Si le fichier n'existe pas, alors le code dans \m{faux} est ex\'ecut\'e.
 
Cette commande est impl\'ement\'ee en utilisant |\IfFileExists|.


\subsection{Rapport d'erreurs}
 
Ces commandes doivent \^etre utilis\'ees dans la troisi\`eme partie des classes ou
packages pour rapporter des erreurs ou fournir des informations aux auteurs.
 
\begin{decl}
  |\ClassError| \arg{nom-classe} \arg{texte-erreur} \arg{texte-aide}\\
  |\PackageError| \arg{nom-package} \arg{texte-erreur} \arg{texte-aide}
\end{decl}
Ceci produit un message d'erreur.  Le \m{texte-erreur} est affich\'e et le
message d'erreur |?| est affich\'e.  si l'utilisateur tape |h|, \m{texte-aide}
sera affich\'e.
 
\`A l'int\'erieur de  \m{texte-erreur} et \m{texte-aide}, |\protect| peut \^etre
utilis\'e afin d'arr\^eter l'expansion d'une commande~; |\MessageBreak| provoque un
retour \`a la ligne et |\space| affiche un espace.

Notez que le \m{texte-erreur} se verra ajout\'e un point final. N'en mettez donc 
pas dans l'argument.

Par exemple:
\begin{verbatim}
   \newcommand{\foo}{FOO}
   \PackageError{ethel}{%
      Votre aeroglisseur est plein d'anguilles,\MessageBreak
      et \protect\foo\space est \foo
   }{%
      Oh mon Dieu! Quelque chose ne va pas.\MessageBreak
      \space \space Essayez de taper \space <<return>>
      \space pour poursuivre, et ignorer \protect\foo.
   }
\end{verbatim}
produit l'affichage~:
\begin{verbatim}
   ! Package ethel Error:  Votre aeroglisseur est plein d'anguilles,
   (ethel)                et \foo est FOO.

   See the ethel package documentation for explanation.
\end{verbatim}
Si l'utilisateur tape |h|, le message suivant apparaîtra~:
\begin{verbatim}
   Oh mon Dieu! Quelque chose ne va pas.
     Essayez de taper  <<return>>  pour poursuivre, et ignorer \foo.
\end{verbatim}
 
\begin{decl}
  |\ClassWarning| \arg{nom-classe} \arg{texte-avertissement}\\
  |\PackageWarning| \arg{nom-package} \arg{texte-avertissement}\\
  |\ClassWarningNoLine| \arg{nom-classe} \arg{texte-avertissement}\\
  |\PackageWarningNoLine| \arg{nom-package} \arg{texte-avertissement}\\
  |\ClassInfo| \arg{nom-classe} \arg{texte-info}\\
  |\PackageInfo| \arg{nom-package} \arg{texte-info}
\end{decl}
Les quatre  commandes |Warning| sont identiques aux commandes d'erreur, \`a ceci pr\`es
qu'elles ne produisent que des avertissements \`a l'\'ecran, sans prompt d'erreur.

Les deux premi\`eres, les versions |Warning|, indiquent \'egalement le num\'ero de la ligne 
o\`u l'avertissement a \'et\'e produit tandis que les deux suivantes, les versions |WarningNoLine|
ne le font pas.

Les deux  commandes |Info| sont identiques, \`a ceci pr\`es qu'elles n'enregistrent les
informations que dans le fichier de transcription, y compris le num\'ero de ligne.
Il n'existe aucune version |NoLine| pour ces deux commandes.

\`A l'int\'erieur du \m{texte-averstissement} et \m{texte-info}, |\protect| peut \^etre
utilis\'e afin d'arr\^eter l'expansion d'une commande~; |\MessageBreak| provoque un
retour \`a la ligne et |\space| affiche un espace.
De plus, aucun point final ne devrait \^etre ins\'er\'e car il y en a un 
ins\'er\'e automatiquement.
 

\subsection{D\'efinition de commandes}
\label{Sec:commandes.define}
 
\LaTeXe{} fournit des m\'ethodes suppl\'ementaires de (re)d\'efinition de commandes destin\'ees \`a
\^etre utilis\'ees dans les fichiers de classe et package.

\NEWfeature{1994/12/01}
Les formes \texttt{*} de ces commandes doivent \^etre utilis\'ees pour d\'efinir des 
commandes qui ne sont pas, au sens \TeX{}, longues.  Ceci peut s'av\'erer utile pour 
les gestions d'erreur avec des commandes dont les arguments ne sont pas destin\'es \`a 
contenir des paragraphes entiers de texte.

\begin{decl}
  |\DeclareRobustCommand| \arg{cmd} \oarg{num} \oarg{defaut}
     \arg{définition}\\
  |\DeclareRobustCommand*| \arg{cmd} \oarg{num} \oarg{defaut}
     \arg{définition}
\end{decl}
Cette commande prend les m\^emes arguments que |\newcommand| mais elle d\'eclare
une commande robuste, m\^eme si le code \`a l'int\'erieur de \m{définition} est
fragile.  Vous pouvez utiliser cette commande pour d\'efinir de nouvelles commandes robustes, ou
pour red\'efinir des commandes existantes et les rendre robustes. Un enregistrement est
ins\'er\'e dans le fichier de transcription si la commande est red\'efinie.
 
Par exemple, si |\seq| est d\'efinie comme suit~:
\begin{verbatim}
   \DeclareRobustCommand{\seq}[2][n]{%
     \ifmmode
       #1_{1}\ldots#1_{#2}%
     \else
       \PackageWarning{fred}{Vous ne pouvez utiliser \protect\seq\space dans le texte}%
     \fi
   }
\end{verbatim}
alors la commande |\seq| peut \^etre utilis\'ee avec des arguments changeants, m\^eme si
|\ifmmode| ne le peut pas~; par exemple:
\begin{verbatim}
   \section{Truc concernant la s\'equence $\seq{x}$}
\end{verbatim}

Notez \'egalement qu'il n'y a pas besoin de mettre un |\relax| avant le
|\ifmmode| au d\'ebut de la d\'efinition: ceci est d\^u au fait que la
protection donn\'ee par ce |\relax| contre l'expansion au mauvais moment est fournie de
mani\`ere interne.

\begin{decl}
  |\CheckCommand| \arg{cmd} \oarg{num} \oarg{defaut}
     \arg{definition}\\
  |\CheckCommand*| \arg{cmd} \oarg{num} \oarg{defaut}
     \arg{definition}
\end{decl}
Cette commande prend les m\^emes arguments que |\newcommand| mais, plut\^ot que de red\'efinir
\m{cmd}, elle v\'erifie juste que la d\'efinition courante de \m{cmd} est
exactement celle donn\'ee par \m{definition}. Une erreur est soulev\'ee si ces 
d\'efinitions diff\`erent.
 
Cette commande est utile pour v\'erifier l'\'etat du syst\`eme avant que 
votre package ne commence \`a modifier les d\'efinitions des commandes. Elle vous
permet de v\'erifier qu'en particulier aucun autre package n'a red\'efini la m\^eme
commande.

\subsection{Arguments changeants}

\NEWdescription{1994/12/01}
L'\'etablissement d'une protection pendant le traitement (i.e.~changement) d'arguments changeants
a \'et\'e r\'eimpl\'ement\'e, comme l'a \'et\'e la m\'ethode d'\'ecriture d'informations du fichier 
|.aux| vers d'autres fichiers tels que le fichier |.toc|. Des d\'etails peuvent
\^etre trouv\'es dans le fichier |ltdefns.dtx|.

Nous esp\'erons que ces changements n'affecteront pas beaucoup de packages.

\section{Commandes diverses, etc}
\label{Sec:commandes.misc}

\subsection{Param\`etres de mise en page}
 
\begin{decl}
|\paperheight|\\
|\paperwidth|
\end{decl}
Ces deux param\`etres sont habituellement initialis\'es par la classe
comme \'etant les dimensions du papier utilis\'e. Ils devraient \^etre 
les dimensions r\'eelles du papier, au contraire de 
|\textwidth| et |\textheight| qui correspondent \`a la taille du corps de
texte principal, entre les marges.


\subsection{Changement de casse}
\label{sec:case}

\begin{decl}
  |\MakeUppercase| \arg{text} \\
  |\MakeLowercase| \arg{text}
\end{decl}

\NEWfeature{1995/06/01}
\TeX{} fournit deux primitives |\uppercase| et |\lowercase| pour
changer la casse du texte. Celles-ci sont parfois utilis\'ees dans des classes 
de document pour mettre les informations dans les ent\^etes en majuscules.

Malheureusement, ces primitives \TeX{} ne changent pas la casse de 
caract\`eres obtenus par des commandes comme  |\ae| ou |\aa|.  Pour r\'esoudre ce
probl\`eme, \LaTeX{} fournit deux nouvelles commandes |\MakeUppercase| et
|\MakeLowercase|, qui font cela.

Par exemple~:
\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}

Les commandes |\MakeUppercase| et |\MakeLowercase| sont elles-m\^emes 
robustes, bien qu'elles aient des arguments changeants.

Ces commandes utilisent les  primitives \TeX{} |\uppercase| et |\lowercase|,
et donc ont un certain nombre de <<~fonctions~>> inattendues. En particulier, elles
changent la casse de tout (sauf les caract\'eres des noms de commandes)
ce qui se trouve dans le texte de leur argument~: ceci inclut les mathematiques,
les noms d'environnement et les noms de label.

Par exemple:
\begin{verbatim}
   \MakeUppercase{$x+y$ en \ref{foo}}
\end{verbatim}
produit $X+Y$ et l'avertissement~:
\begin{verbatim}
   LaTeX Warning: Reference `FOO' on page ... undefined on ...
\end{verbatim}
\`A long terme, nous aimerions utiliser les fontes toutes en majuscules plut\^ot qu'une 
commande comme |\MakeUppercase|, mais ceci n'est pas possible pour le moment
car de telles fontes n'existent pas.

\NEWdescription{1995/12/01}
Afin que ce changement de casse marche raisonnablement bien et que
les coupures de mots soient correctes,  \LaTeXe{} \emph{doit} utiliser,
tout au long d'un document, la m\^eme table fix\'ee de changement de casse.
La table utilis\'ee est \'etablie pour l'encodage de fonte |T1|~; cela marche bien
avec les fontes standard \TeX{} pour tous les alphabets latins mais causera des
probl\`emes lors de l'utilisation d'autres alphabets.

\subsection{L'option `openany' dans la classe `book'}

\NEWdescription{1996/06/01}
L'option |openany| permet aux chapitres et autres d\'ebuts semblables de survenir \'eventuellement
sur les pages de gauche. Auparavant, cette option affectait seulement
|\chapter| et |\backmatter|.  Elle a d\'esormais \'egalement un influence sur
|\part|, |\frontmatter| et |\mainmatter|.

\subsection{Environnements d'affichage de maths mieux d\'efinis}

\begin{decl}
  |\ignorespacesafterend|
\end{decl}

\NEWfeature{1996/12/01}
Supposez que vous voulez d\'efinir un environnement pour afficher du texte
num\'erot\'e comme une \'equation. Une fa\c{c}on simple de faire cela 
est d'\'ecrire~:
\begin{verbatim}
  \newenvironment{texteqn}
    {\begin{equation}
       \begin{minipage}{0.9\linewidth}}
      {\end{minipage}
     \end{equation}}
\end{verbatim}
Toutefois, si vous avez d\'ej\`a essay\'e cela, vous avez probablement
remarqu\'e que cela ne marche pas parfaitement au milieu  d'un paragraphe
car un espace de s\'eparation de mots appara\^it au d\'ebut de la premi\`ere
ligne apr\`es l'environnement.

Il existe d\'esormais une commande suppl\'ementaire (avec un nom tr\`es long) disponible 
que vous pouvez utiliser afin de rem\'edier \`a ce probl\`eme~; elle doit
\^etre ins\'er\'ee de la mani\`ere suivante~:
\begin{verbatim}
  \newenvironment{texteqn}
    {\begin{equation}
       \begin{minipage}{0.9\linewidth}}
      {\end{minipage}
     \end{equation}
     \ignorespacesafterend}
\end{verbatim}

\subsection{Normalisation de l'espacement}

\begin{decl}
  |\normalsfcodes|
\end{decl}

\NEWfeature{1997/06/01}
Cette commande devrait \^etre utilis\'ee pour restaurer les valeurs normales des 
param\`etres influen\c{c}ant l'espacement entre les mots, les phrases, etc.

Une utilisation importante de cette fonction est de corriger un probl\`eme signal\'e par
Donald Arseneau~: la ponctuation dans les ent\^etes a toujours (dans tous les formats
 \TeX{} connus) \'et\'e potentiellement incorrecte lorsqu'un changement de page survenait
 pendant qu'une valeur locale des codes d'espacement est en vigueur. Ces codes d'espacement
sont chang\'es, entre autres, par la commande 
\verb|\frenchspacing|) et l'environnement \textsf{verbatim}.

La d\'efinition correcte de ces codes est normalement automatiquement 
donn\'ee dans le |\begin{document}| et n'a donc pas besoin d'\^etre explicitement faite~;
cependant, s'ils sont explicitement rendus non-vides dans le fichier d'une classe, alors
l'initialisation automatique par d\'efaut sera annul\'ee.


\section{Remise \`a jour des classes et packages \LaTeX~2.09}
\label{Sec:upgrade}
 
Cette section d\'ecrit les changements que vous pouvez avoir besoin de faire lorsque
vous remettez \`a jour un style \LaTeX{} existant vers un package ou une classe. Le mieux
est de toutefois partir sur une note optimiste.
 
Beaucoup des fichiers de style existants s'ex\'ecuteront avec \LaTeXe{} sans la moindre
modification au fichier lui-m\^eme. Si tout marche correctement,
ins\'erez dans la classe ou package nouvellement cr\'e\'e une note afin de 
pr\'eciser qu'il marche avec le nouveau standard \LaTeX{}~; ensuite, vous pouvez le distribuer aux
utilisateurs.

\subsection{Essayez d'abord!}
\label{Sec:try-it}

La premi\`ere chose \`a faire est de tester votre style en mode compatibilit\'e.
Le seul changement n\'ecessaire pour faire cela est de changer l'extension 
du fichier en  |.cls|~: ce changement n'est \`a faire que si 
votre fichier \'etait utilis\'e en tant que style de document principal.
Alors, sans aucune autre modification, ex\'ecutez \LaTeXe{} sur un document qui
utilise votre fichier.  Ceci suppose que vous ayez un collection appropri\'ee de
fichiers qui testent toutes les fonctionnalit\'es fournies par votre fichier de 
style. (Si ce n'est pas le cas, c'est le moment d'en cr\'eer un!)

Il vous faut alors modifier les documents de test de telle sorte qu'ils deviennent des
documents \LaTeXe{}~: voir \emph{\usrguide} pour obtenir des d\'etails sur comment faire
cela. Puis r\'eessayez-les. Vous avez d\'esormais essay\'e les documents test 
dans le mode natif \LaTeXe{} et le mode compatiblit\'e \LaTeX~2.09.

\subsection{R\'esolution de probl\`emes}
\label{Sec:trouble}

Si votre fichier ne marche pas avec \LaTeXe{}, il y a deux raisons possibles.
\begin{itemize}
\item \LaTeX{} poss\`ede \`a pr\'esent une interface robuste et bien d\'efinie pour
  la s\'election de fontes, diff\'erant \'enorm\'ement de \LaTeX~2.09.
\item Votre fichier de style peut avoir utlis\'e quelques-unes des commandes internes \LaTeX~2.09
  qui ont chang\'e ou ont \'et\'e supprim\'ees.
\end{itemize}

Quand vous corrigerez votre fichier, vous aurez probablement besoin de plus
d'informations que celles affich\'ees normalement par \LaTeXe. Ceci peut \^etre
fait en initialisant le compteur |errorcontextlines| de sa valeur de d\'efaut de 
$-1$ \`a une valeur bien plus grande, par ex.~999.

\subsection{Satisfaire le mode compatibilit\'e}

Parfois, une collection existante de documents \LaTeX~2.09 rendent inopportunes
ou impossibles l'abandon entier des anciennes commandes.
Si tel est le cas, il est alors possible de satisfaire les deux conventions
en faisant des traitements sp\'eciaux pour les documents trait\'es en
mode compatibilit\'e.

\begin{decl}
|\if@compatibility|
\end{decl}
Ce test est initialis\'e lorsqu'un document d\'ebute par |\documentstyle| au lieu
de |\documentclass|. Un code appropri\'e peut alors \^etre fourni pour l'une ou l'autre
des conditions, comme suit~:
\begin{verbatim}
   \if@compatibility
     <code emulant le comportement LaTeX 2.09>
   \else
     <code convenant a LaTeX2e>
   \fi
\end{verbatim}


\subsection{Commandes de fontes}
 
Des commandes de fontes et de tailles sont maintenant d\'efinies par 
la classe de document \`a la place du noyau \LaTeX{}.  Si vous remettez \`a jour
un style de document 
\LaTeX~2.09 vers une classe qui ne charge pas une des classes standard,
alors il vous faudra probablement ajouter les d\'efinitions de
ces commandes.
 
\begin{decl}
   |\rm| |\sf| |\tt| |\bf| |\it| |\sl| |\sc|
\end{decl}
Aucune de ces formes courtes de commandes de s\'elections ne sont 
d\'efinies  dans le noyau
\LaTeXe{}.  Elles sont d\'efinies par tous les fichiers de classe standard.

Si vous voulez les d\'efinir dans le fichier de votre classe, il y a plusieurs fa\c{c}ons de le faire.

Une d\'efinition possible est~:
\begin{verbatim}
   \newcommand{\rm}{\rmfamily}
   ...
   \newcommand{\sc}{\scshape}
\end{verbatim}
Ceci rendrait les commandes de fontes othogonales~; par exemple
|{\bf\it texte}| produirait de l'italique gras, ainsi~: \textbf{\textit{texte}}.
Elles provoqueront \'egalement une erreur si elles sont utilis\'ees en mode math.
 
Une autre d\'efinition possible est~:
\begin{verbatim}
   \DeclareOldFontCommand{\rm}{\rmfamily}{\mathrm}
   ...
   \DeclareOldFontCommand{\sc}{\scshape}{\mathsc}
\end{verbatim}
Ceci fera agir |\rm| comme |\rmfamily| en mode texte (voir ci-dessus) et 
lui fera s\'electionner l'alphabet math |\mathrm| en mode math.

Ainsi |${\rm math} = X + 1$| produira <<~${\rm math} = X + 1$~>>.

Si vous ne voulez pas que la s\'election de fonte soit orthogonale, vous pouvez alors
suivre les classes standard et d\'efinir~:
\begin{verbatim}
   \DeclareOldFontCommand{\rm}{\normalfont\rmfamily}{\mathrm}
   ...
   \DeclareOldFontCommand{\sc}{\normalfont\scshape}{\mathsc}
\end{verbatim}
Cela signifie, par exemple, que |{\bf\it texte}| produira une graisse moyenne 
(plut\^ot que grasse) italique, comme ceci~: \textit{texte}.  

\begin{decl}
   |\normalsize| \\
   |\@normalsize|
\end{decl}
La commande |\@normalsize| est conserv\'ee pour la compatibilit\'e avec les 
packages \LaTeX~2.09 qui peuvent avoir utilis\'e sa valeur~; toutefois, la red\'efinir
dans un fichier de classe n'aura aucun effet car elle est toujours
r\'einitialis\'ee pour avoir la m\^eme signification que |\normalsize|.

Cela veut dire que les classes \emph{doivent} d\'esormais red\'efinir |\normalsize| plut\^ot
que de red\'efinir |\@normalsize|~; par exemple (exemple plut\^ot incomplet)~:
\begin{verbatim}
   \renewcommand{\normalsize}{\fontsize{10}{12}\selectfont}
\end{verbatim}
Notez que |\normalsize| est d\'efini par le noyau \LaTeX{} pour \^etre
un message d'erreur.

\begin{decl}
   |\tiny| |\footnotesize| |\small| |\large|\\
   |\Large| |\LARGE| |\huge| |\Huge|
\end{decl}
Aucune de ces autres commandes de changement de taille <<~standard~>>
ne sont d\'efinies dans le noyau~: chacune d'entre elles doit \^etre d\'efinie
dans un fichier de classe si vous en avez besoin. Elles sont toutes d\'efinies
par les classes standard.

Cela signifie que vous devriez utiliser |\renewcommand| pour |\normalsize| et
|\newcommand| pour les autres commandes de changement de taille.


\subsection{Commandes obsol\`etes}
 
Certains packages ne marcheront pas avec \LaTeXe{}, normalement parce qu'ils comptaient
sur une commande interne \LaTeX{} qui n'\'etait pas garantie ou document\'ee et a \'et\'e depuis
chang\'ee ou retir\'ee.
 
Dans beaucoup de cas, il y aura d\'esormais un moyen robuste de haut niveau pour 
r\'ealiser ce qui avant n\'ecessitait des commandes bas-niveau. Veuillez 
consulter la section~\ref{Sec:commandes} pour voir si vous pouvez utiliser les 
commandes \LaTeXe{} d'auteur de classe et package.

De plus, si votre package ou classe red\'efinit une des commandes du noyau 
(i.e.~celles d\'efinies dans les fichiers |latex.tex|, |slitex.tex|, 
|lfonts.tex|, |sfonts.tex|), alors il vous faudra bien s\^ur v\'erifier 
attentivement si l'impl\'ementation n'a pas chang\'e ou si la commande 
existe encore dans le noyau \LaTeXe{}.

Trop des commandes internes de \LaTeX~2.09 ont \'et\'e r\'eimpl\'ement\'ees ou 
retir\'ees pour les lister toutes ici. Il vous faut v\'erifier celles que
vous avez utilis\'ees ou chang\'ees.

Nous allons, toutefois, lister quelques-unes des  
commandes les plus importantes qui ne sont plus g\'er\'ees.
 
\begin{decl}
   |\tenrm| |\elvrm| |\twlrm| \dots\\
   |\tenbf| |\elvbf| |\twlbf| \dots\\
   |\tensf| |\elvsf| |\twlsf| \dots\\
   \qquad$\vdots$
\end{decl}
Les soixante-dix (approximativement) commandes internes de cette forme ne sont 
plus d\'efinies. Si votre classe ou package les utilise, alors \emph{s'il vous 
plaît}, veuillez les remplacer par les nouvelles commandes de fontes d\'ecrites 
dans \emph{\fntguide}.

Par exemple, la commande |\twlsf| devrait \^etre remplac\'ee par~:
\begin{verbatim}
   \fontsize{12}{14}\normalfont\sffamily\selectfont
\end{verbatim}

Une autre possibilit\'e est d'utiliser le package |rawfonts|, d\'ecrit dans
\emph{\usrguide}.

Souvenez-vous en outre que beaucoup des fontes pr\'e-charg\'ees par \LaTeX~2.09 
ne le sont plus.

\begin{decl}
   |\vpt| |\vipt| |\viipt| \dots
\end{decl}
Ces commandes \'etaient des commandes internes de s\'election de taille de \LaTeX~2.09.
(Elles peuvent \^etre encore utilis\'ees en mode compatibilit\'e avec \LaTeX~2.09.)
Veuillez utiliser la commande |\fontsize| \`a la place~: voir \emph{\fntguide} pour
plus de d\'etails.

Par exemple, |\vpt| devrait \^etre remplac\'e par~:
\begin{verbatim}
   \fontsize{5}{6}\normalfont\selectfont
\end{verbatim}

\begin{decl}
  |\prm|, |\pbf|, |\ppounds|, |\pLaTeX| \dots
\end{decl}
\LaTeX~2.09 utilisait plusieurs commandes commen\c{c}ant par |\p| afin de
fournir des commandes <<~prot\'eg\'ees~>> .  Par exemple, |\LaTeX| \'etait d\'efini par
|\protect\pLaTeX|, et |\pLaTeX| \'etait d\'efini pour produire le logo \LaTeX{}. 
Ceci faisait de |\LaTeX| une commande robuste, m\^eme si |\pLaTeX| ne l'\'etait pas.

Ces commandes ont \'et\'e d\'esormais r\'eimplement\'ees en utilisant
|\DeclareRobustCommand|
(d\'ecrite dans la Section~\ref{Sec:commandes.define}).
Si votre package red\'efinit une des commandes |\p|, il vous faut alors 
retirer la red\'efinition et utiliser |\DeclareRobustCommand| pour red\'efinir
la commande non-|\p|.
 
\begin{decl}
|\footheight|\\
|\@maxsep|\\
|\@dblmaxsep|
\end{decl}
Ces param\`etres ne sont pas utilis\'es par \LaTeXe{}; ils ont donc \'et\'e retir\'es, 
sauf en mode compatibilit\'e  \LaTeX~2.09.  Les classes ne doivent plus les utiliser.
 
\begin{thebibliography}{1}
 
\bibitem{A-W:GMS94}
Michel Goossens, Frank Mittelbach, et Alexander Samarin.
\newblock {\em The {\LaTeX} Companion}.
\newblock Addison-Wesley, Reading, Massachusetts, 1994.
 
\bibitem{A-W:DEK91}
Donald~E. Knuth.
\newblock {\em The \TeX book}.
\newblock Addison-Wesley, Reading, Massachusetts, 1986.
\newblock R\'evis\'e pour couvrir \TeX3, 1991.
 
\bibitem{A-W:LLa94}
Leslie Lamport.
\newblock {\em {\LaTeX:} A Document Preparation System}.
\newblock Addison-Wesley, Reading, Massachusetts, seconde \'edition, 1994.
 
\end{thebibliography}

\newpage
\thispagestyle{empty}

\section*{Page de r\'esum\'e \LaTeXe{}~: remettre \`a jour d'anciens styles}

Les sections de r\'ef\'erences ci-dessous sont celles du \emph{\clsguide}%
\footnote{\emph{NdT~:} <<~\LaTeXe~pour les auteurs de classes et packages~>>, le pr\'esent document}.

\begin{enumerate}

\item Ce style doit-il devenir une classe ou un package?
  Voir la section~\ref{Sec:classorpkg} pour savoir comment r\'epondre \`a cette question.

\item S'il utilise un autre fichier de style, alors il vous faudra obtenir une version remise 
\`a jour de cet autre fichier. Voir \`a la section~\ref{Sec:loading}
  pour informations sur comment charger d'autres fichiers de classe et de package.

\item Essayez-le~: voir la Section~\ref{Sec:try-it}.

\item \c{C}a a march\'e?  Excellent, mais il vous reste probablement des choses \`a changer 
 afin de faire de votre fichier un fichier \LaTeXe{} bien structur\'e, et \`a la fois robuste et 
 portable. Il vous faut donc \`a pr\'esent lire la Section~\ref{Sec:writing}, et plus 
 particuli\`erement~\ref{Sec:general}. Vous trouverez \'egalement des exemples utiles 
 dans la Section~\ref{Sec:structure}.

  Si votre fichier pr\'epare de nouvelles fontes, des commandes de changement de fontes ou des symboles,
  vous devriez \'egalement lire \emph{\fntguide}.
  
\item \c{C}a n'a pas march\'e?  Il y alors trois possibilit\'es~:
  \begin{itemize}
  \item  des messages d'erreur sont produits pendant la lecture de votre fichier~;
  \item  des messages d'erreur sont produits pendant le traitement des documents tests~;
  \item  il n'y a pas d'erreur, mais la sortie n'est pas ce qu'elle devrait \^etre.
  \end{itemize}
  N'oubliez pas de v\'erifier attentivement cette derni\`ere \'eventualit\'e.

  Si vous en \^etes \`a cette \'etape, il vous faut alors lire la
  Section~\ref{Sec:upgrade} pour trouver les solutions qui feront marcher votre fichier.
\end{enumerate}

\end{document}

