path: root/support/w2latex/Doc/W2LaTeX.tex

\documentstyle[twoside,french]{article}
\pagestyle{headings}
 
\begin{titlepage}
\title{\bf W2\LaTeX : Traducteur de Formats Descripteurs de Texte}
\author{{Javier Garmendia} \\ {\scriptsize jgarmend@cyberspace.org}\\
	{Pour le Centre International de Rencontres Math\'ematiques} \\ 
	{Jean-Louis Maltret} \\ {\scriptsize jlm@cirm.univ-mrs.fr}}
\date{Juin-Juillet 1994}
\end{titlepage}
 
\begin{document}
 
\maketitle
\begin{abstract}
W2\LaTeX\ est un outil de conversion entre deux formats descripteurs de texte, 
permettant de traduire un document r\'edig\'e sous certaines versions de Word\copyright pour
obtenir du code \LaTeX . Le document source pour W2\LaTeX\ devra \^etre, afin de faciliter la 
portabilit\'e, en RTF (Rich Text Format), un format propri\'etaire de 
Microsoft\copyright .
\par
W2\LaTeX\ n'utilise pas les fonctions cr\'e\'ees par Paul Dubois pour r\'ealiser des lecteurs RTF.
 Ceci pr\'esente en partie l'avantage d'avoir une reconnaissance propre du document d'origine en 
suivant les sp\'ecifications de Microsoft pour Word 6.0. 
Il est constitu\'e 
d'un seul programme executable, sans feuilles de style, sans lybraries \`a installer. On peut attendre
 de W2\LaTeX\ une conversion de documents contenant des param\`etres de pr\'esentation et de mise en page, mais 
aussi de formules math\'ematiques, et de certains types de tableaux.
\par
Ce document contient des informations techniques sur le programme.

\end{abstract}
\newpage
\pagebreak
\tableofcontents
\newpage
 
\section{Consid\'erations G\'en\'erales}
\subsection{Les diff\'erents types de tokens}
\par	Le but de l'analyseur lexical est de d\'ecouper le texte \`a analyser en tokens
qui seront transmis \`a la fonction r\'ealisant l'analyse gramaticale (que nous appellerons
yyparse). Cette fonction v\'erifie la correction syntaxique du texte original, et d\'etermine \`a 
chaque instant
quelle construction a \'et\'e r\'ealis\'ee, et ce que cela repr\'esente.
\par
	Nous avons declar\'e plusieurs sortes de tokens, car le type de leur valeur s\'emantique
variera pour certains d'entre eux. Bison (et bien s\^ur Yacc aussi) imposent la limitation suivante au
niveau de l'analyse semantique des tokens: \begin{quote} Seuls les tokens de type char pourront avoir 
une valeur s\'emantique permettant de les diff\'erentier gramaticalement. \end{quote}
Ainsi, nous pourrons d\'eclarer des r\`egles
de grammaire du style:
\begin{quote}
		expression:	terme operateur terme;
\end{quote}
	O\`u op\'erateur est un {\bf +} ou un {\bf-}; Mais il est aussi possible de faire:
\begin{quote}
		expression:	terme '+' terme $|$ terme '-' terme ;
\end{quote}
\par
	Cette derni\`ere r\`egle prendra en compte la valeur du token interm\'ediaire pour d\'eterminer s'il s'agit
d'une addition ou d'une soustraction. Par contre, il n'est pas possible de passer un mot de commande
compos\'e de plusieurs caract\`eres ou ayant une structure plus complexe. Par exemple:
\begin{quote}
		racine:		'sqrt' expression;
\end{quote}
	n'est pas une r\`egle valable.
\par
	Il faut donc avoir un analyseur lexical qui fasse la relation entre les chaines de caract\`eres
et des entiers, qui seront des tokens typ\'es comme des chaines de charact\`eres. Ceci afin de 
r\'ecup\'erer la valeur
s\'emantique pour un traitement ult\'erieur. En reprenant l'exemple pr\'ec\'edent, on d\'eclarerait:
\begin{quote}
		\%token $<$char *$>$ SQRT\\
		racine:		SQRT expression;
\end{quote}
	et l'analyseur lexical attriburait:
\begin{quote}
		yylval="sqrt";\\
		return SQRT;
\end{quote}
\par
	Dans notre cas, nous aurons besoin de plusieurs types de tokens. Un type pour les mots de commande.
Un autre pour les valeurs num\'eriques, ainsi qu'un type pour le texte. Nous rajouterons en plus un type
pour les caract\`eres individuels, et un type pour les caract\`eres qui sont un mot de commande.
 Cette declaration
Bison se fait de la fa\c{c}on suivante:
\begin{quote}
		\%union \{ char calu; int numo; char* motcomm; char carcomm; char* pcdata; \}
\end{quote}
	dans le fichier de grammaire.
	Ensuite il faudra typer les tokens.

\subsection{La structure d'un mot de commande RTF}

	Un mot de commande RTF est compos\'e des \'el\'ements suivants:
\begin{itemize}
\item Le caract\`ere "$\backslash$".
\item Des caract\`eres alphab\'ethiques minuscules.
\item Un \'eventuel param\`etre chiffr\'e.
\item Un s\'eparateur.
\begin{itemize}
\item Dans le cas o\`u un param\`etre num\'erique est pr\'esent, il n'est pas n\'ecessaire d'avoir de
s\'eparateur. 
\item Dans les autres cas, le s\'eparateur peut \^etre: "$\backslash$", "\{", "\}, ";", " ".
\item Si le s\'eparateur est un espace " ", il sera ignor\'e. Sinon, le s\'eparateur sera transmis
comme token \`a la prochaine analyse.
\end{itemize}
\end{itemize}

\subsection{Les diff\'erents \'etats}

	Lors de l'analyse du code RTF, il faut tenir compte de l'etat contextuel pour 
effectuer l'analyse lexicale differemment. Il y a plusieurs etats:
\begin{enumerate}
\item RTF:
\begin{quote}
	 	C'est le cas standard. On analyse et reconnait les mots de commande
		et les passages de texte. On tiens compte aussi des caract\`eres de
		commande comme d\`ecrit plus bas.	
\end{quote}
\item Equation:
\begin{quote}
		Si on se trouve dans ce mode, il faut tenir en compte le fait que 
		l'on a modifi\'e le fichier d'entr\'ee, et qu'il s'agit maintenant du
		fichier auxiliaire. Les caract\`eres de commande prennent une 
		signification particuliaire.
\end{quote}
\item Erreur:
\begin{quote}
		On a d\'etect\'e une erreur, et on analyse de fa\c{c}on \`a pouvoir la corriger.
		Il faut alors sauter des morceaux de RTF (et donc perdre des informations)
		mais de fa\c{c}on \`a en conserver le maximun.
\end{quote}
\end{enumerate}

\subsection{L'analyseur lexical}
	
	La structure de l'analyseur lexical est la suivante:
\begin{enumerate}
\item Si on est en \'etat de traitement des erreurs:
\begin{enumerate}
\item Si c'est le premier token demand\'e juste apr\`es la d\'etection de l'erreur:
\begin{quote}
		On avance jusqu'au debut du paragraphe suivant, et
		on retourne le token PZERROR apr\`es avoir ins\'er\'e dans le fichier de sortie
		le message d'erreur en \LaTeX .
\end{quote}
\item Si c'est le deuxi\`eme:
\begin{quote}
		On retourne PAR, et on anule l'\'etat de traitement des erreurs.
\end{quote}
\end{enumerate}
\item On lit un caract\`ere dans le fichier d'entr\'ee:
\item Si on est en mode Equation et si c'est un d\'elimiteur d'\'equation:
\begin{quote}
		 On le retourne.
\end{quote}
\item Si on a trouv\'e la fin du fichier d'entr\'ee:
\begin{enumerate}
\item Si on \'etait en mode Equation (fichier d'entr\'ee auxiliaire), on replace le bon
	  fichier d'entr\'ee pour la suite.
\item Sinon, on a termin\'e l'analyse.
\end{enumerate}
\item S'il s'agit d'un retour \`a la ligne:
\begin{quote} 
	On l'ignore: RTF coupe les lignes comme il veut.
\end{quote}
\item S'il s'agit d'un caract\`ere d\'elimiteur: '\{' '\}' ';'
\begin{quote}
	 On le retourne.
\end{quote}
\item S'il s'agit d'un d\'ebut de mot de commande: '$\backslash$'
\begin{enumerate}
\item On lit le reste de la commande.
\item En tenant compte des caract\`eres sp\'eciaux: '\{' '\}' '$\backslash$' ';'
	 et en v\'erifiant que le mot de commande existe.
\item Si le mot de commande n'existe pas ou n'est pas connu,
		il est ignor\'e.
\item S'il s'agit d'un caract\`ere de contr\^ole, on lit le param\`etre et on le passe a yyparse.
\item On \'elimine les espaces utilis\'es comme d\'elimiteurs.
\item Il faut tenir compte aussi des particularit\'es du mode \'equation.
\end{enumerate}
\item S'il s'agit d'un nombre et que le mot de commande lu pr\'ec\'edemment acceptait un param\`etre chiffr\'e:
\begin{quote}
	 On lit les caract\`eres composant le nombre et on le passe a yyparse.
\end{quote}
\item Si ce n'est ni un mot de commande, ni un entier, ni un caract\`ere de contr\^ole simple, c'est du texte.
\begin{enumerate}
\item On le range dans un tampon, et on passe a yyparse un token PCDATA avec pour valeur s\'emantique
		le pointeur sur le tampon.
\item Il faut tenir compte aussi des particularit\'es du mode \'equation.
\end{enumerate}
\end{enumerate}
\subsection{Le texte}

	Les portions de texte pur 7bits sont consid\'er\'ees comme des tokens a part entiere et d'un seul bloc.
Le programme W2\LaTeX\ poss\`ede des instructions permettant de v\'erifier que l'on n'exc\`ede pas la taille des tampons alloues, 
auquel cas le tampon est rallong\'e. Ceci permet de traiter les blocs de texte en suivant les sp\'ecifications, et o\`u la
seule limitation de place serait due \`a un manque de m\'emoire de la machine (ou de m\'emoire allou\'ee par process). Ce texte sera
transcrit tel quel dans le fichier \LaTeX\ de destination.
\par
	Une seule limitation est pr\'evue \`a cet effet: certains caract\`eres 7 bits ont une signification particuliaire pour
\LaTeX . Ils seront traduits en leur equivalent par la fonction {\tt puretext}. (e.g.: \$ \_ / ...).

\subsection{Les environnements}

	La traduction des differents environnements est faite d\`es la reconnaissance d'un d\'ebut d'environnement. C'est \`a dire,
que l'on n'attend pas la fin d'un paragraphe, ou d'une portion de texte dans un environnement particulier pour le transcrire.
Ceci facilite le traitement Bison, mais se montre probl\'ematique parfois. Pour faciliter la t\^ache, nous avons implement\'e de nombreuses
variables globales, \`a titre de FLAGS, qui sont lev\'ees au moment de l'\'etablissement d'un envirronnement, et qui sont baiss\'ees lors
de la fermeture du mode en question. 
\par
	Par exemple, d\`es que l'on trouve le mot de commande RTF 'qc' qui signifie que le paragraphe suivant va \^etre centr\'e, W2\LaTeX\ 
produit sur le fichier de sortie l'equivalent \LaTeX : '\verb+\begin{center}+'. Ensuite, lors de la fin du paragraphe, il faut v\'erifier le
contexte. Si RTF ne le pr\'ecise pas autrement, les paragraphes suivants seront aussi centr\'es, et donc on n'a rien \`a faire.
Mais si on retrouve la commande RTF 'pard', il faut remettre tous les flags a 0, et fermer tous les environnements. Heureusement,
le systeme de drapeaux fonctionne car en RTF on ne peut pas imbriquer deux environnements conflictifs. Et dans le cas o\`u des 
environnements de nature diff\'erente seraient pr\'esents simultan\'ement, ils seront hi\'erarchis\'es, et leur ordre de priorit\'e sera
invers\'e lors de la fermeture. A titre d'exemple, le typage des caracteres (bold, italique ...) est moins prioritaire que le 
typage des paragraphes (centr\'e ...).

\subsection{Les formules}

	Les formules ne font pas partie de RTF lui-m\^eme, et les sp\'ecifications correspondantes sont fonction de l'aplication
qui a g\'en\'er\'e le document. En cons\'equence, il faudra re-programmer les fonctions de traitement de ces champs pour des documents g\'en\'er\'es
par d'autres aplications que Word 6.0 et que les versions 5.0 pour Mac et 2.0 pour PC qui sont celles qui ont d\'ej\`a \'et\'e impl\'ement\'ees.
\par
	Les formules font partie d'un ensemble de champs nom\'es a juste titre 'fields' dans les specifications RTF. Nous disposons
des sp\'ecifications des fields de Word 6.0, qui ressemblent fortement (aux majuscules, symboles delimiteurs, et quelques mots de
commande pr\`es) aux versions pr\'ec\'edentes de Word pour Mac et PC.
\par
	Remarquons qu'il existe toute une panoplie de 'fields' propres a Word qui n'ont pas \'et\'e consid\'er\'es dans la version
actuelle de W2\LaTeX .


\subsection{Les Fontes}

	Nous n'avons pas tent\'e d'impl\'ementer de nouvelles polices de caract\`eres pour ne pas rentrer en conflict avec des configurations
o\`u elles ne seraient pas pr\'esentes. Donc, toutes les polices sont transform\'ees en cmr, aux exceptions suivantes:
\begin{enumerate}
\item La police Symbol (Microsoft garanti (?) que cette police aura la m\^eme structure sur Mac que sur PC). Elle est enti\`erement
retranscrite avec les \'equivalents \LaTeX\ lorsque ces \'equivalences ou approximations existent. Sinon, un symbole @ sera utilis\'e.
\item Les polices non proportionelles (Courier...) qui seront transcrites en 'tt'.
\begin{quote}
	Cette correspondance entre les polices se trouve dans le fichier rtf.fonts.c dans le tableau EqFontsRTF\_TeX. Toute 
personalisation est ais\'ee par edition de ce fichier et recompilation. Les correspondances entre les symboles se font dans
le m\^eme fichier au sein du tableau FontSymboles.
\end{quote}
\end{enumerate}
	Dans le cas o\`u W2\LaTeX\ serait port\`e pour une utilisation sur un systeme avec d'autres polices ou symboles (cf AMS), l'\'edition
de ces tableaux et des constantes d\'efinissant les tailles des dits tableaux devrait \^etre ais\'ee.
\par
	Il fallait se fixer une police par defaut. Et surtout une taille de police. Le choix a \'et\'e port\'e sur la valeur
prise par Word par defaut lors de l'installation premi\`ere du logiciel: 10pt. Une table se trouvant dans ce m\^eme fichier (rtf.fonts.c) 
d\'ecrit la correspondance entre les tailles des polices en nombre de points et les param\`etres \LaTeX\ (\verb+\small, \Huge, ...+). Notons que cette table a \'et\'e
\'etablie \`a partir des donn\'ees trouv\'ees dans le manuel de \LaTeX , correspondant au style 10pt.

\subsection{L'ent\^ete \LaTeX}

	La taille de la page par defaut est supos\'ee A4. La feuille de style \LaTeX\ correspondante \'etant un standard, ca nous a sembl\'e le
plus judicieux. Toute modification peut se faire dans la grammaire (rtf.y) \`a la ligne decrivant la regle {\tt input}.
\par
	Les marges sont fix\'ees en fonction des param\`etres fournis par le fichier RTF, ainsi que les tailles des indentations, 
et quelques red\'efinitions de noms de polices standard.
\par
	Cette red\'efinition des polices est due \`a la mauvaise d\'ecoupe en blocs de RTF. En effet, certains parametres RTF sont donn\'es
en plein milieu d'un bloc, et on ne sait pas quand est-ce qu'ils vont avoir fin. Ainsi, il est possible de transcrire des blocs sans
d\'elimiteurs de d\'ebut et de fin de bloc. Pour faire en sorte que \LaTeX\ accepte ces changements, il faut forcer un changement de 
police compl\`etement. Vous trouverez une nouvelle instruction (la seule) introduite par W2\LaTeX\ qui d\'efinit simplement la police cmr10.
Il s'agit de la commande '\verb+\pzrm+'.


\subsection{Les tableaux}

	Le c\^ot\'e le plus flou de W2\LaTeX\ se situe certainement au niveau des tableaux. S'ils sont traduits, leur structure de 
tableau n'est pas conserv\'ee. Ils ne seront pas encadr\'es (du moins proprement). Mais le {\em look} \LaTeX\ sera conserv\'e.
\par
	Ceci est du \`a la libert\'e suivante permise en RTF et pas en \LaTeX . En RTF on peut avoir une cellule d'un tableau qui
soit compos\'ee de plusieurs paragraphes, ce qui (sauf erreur de ma part), n'est pas possible directment en \LaTeX\ . A moins de...
transformer le contenu des tableaux en {\em minipages}. C'est ce que nous avons fait. Chaque cellule d'un tableau est une minipage. 
Ces minipages sont juxtapos\'ees sur une meme ligne pour former une ligne du tableau. Heureusement, lorsque \LaTeX\ centre toutes ces
minipages (par defaut; on peut demander autre chose aussi :-) sur la ligne en cours, ce qui fait que l'aspect du tableau, hormis
les cadres, sera le m\^eme. 
\par
	De notables am\'eliorations sont \`a aporter sur ce point l\`a. Nous avons essay\'e de mettre ces minipages dans un tableau,
mais le resulat n'\'etait pas celui esp\'er\'e, car les cellules dans RTF sont donn\'ees par leur largeur, et ca fait en g\'eneral
d\'eborder le tableau de la page. Nous avons quand m\^eme laiss\'e l'option d'encadrer chacune des minipages \`a l'aide d'une fbox.
Le resultat n'est pas beau. Pour l'obtenir, il suffit d'inclure \`a la fin de la ligne de commande l'option '-uglyframes':
\begin{quote}
		$>$ w2latex inputfile.rtf -uglyframes
\end{quote}

\subsection{Autres objets}
	
	Toutes les r\`egles de grammaire (sauf ommission) correspondant \`a des objets OLE ou aux images,
ont \'et\'e cod\'ees dans le fichier
de grammaire: rtf.y. Ils ne sont pas trait\'es pour l'instant. Certains sont irr\'ealisables 
(inclusion de documents g\'en\'er\'es par des tableurs...).
\par
	Les formats \'etant extr\`emement nombreux, il faudrait toute une panoplie de convertisseurs.

\subsection{Images}

	Les images peuvent \^etre cod\'ees de nombreuses fa\c{c}ons, et sous diff\'erents formats. 
Les plus courrants sont le Windows Metafile
et le format de MacDraw. Ne possedant pas les sp\'ecifications de ces formats d'images, nous laisserons 
un cadre blanc de la taille
(approch\'ee) de l'image dans le document \LaTeX\ g\'en\'er\'e.
\par
	La taille des images \'etant cod\'ee parfois en points, parfois en twips, parfois en pixels... 
il est possible que pour des images
g\'en\'er\'ees avec des logiciels de dessin particuliers, il y ait un probl\`eme de taille des cadres blancs.

\subsection{Am\'eliorations \`a r\'ealiser}
Certains points restent sans doute \`a am\'eliorer. En particulier le traitement des tableaux,
les nouveaux fields, et d'\'eventuels nouveaux formats de formules pour des documents g\'en\'er\'es
par d'autres applications ou d'autres versions de Word. 
\par
Il serait int\'eressant de pouvoir disposer de traducteurs de formats d'images pour obtenir
du post-script inclus dans le fichier \LaTeX\ obtenu. Ceci serait possible, car les images (quel
que soit leur format, sont transcrites en hexad\'ecimal dans le fichier RTF. Il est donc possible
d'en faire un fichier de sortie binaire.

\subsection{Comment r\'ealiser des extensions}
En ce qui concerne les formules, il suffit de voir le formatage diff\'erent des formules MAC ou PC.
Ces deux formats ont \'et\'e trait\'es en parall\`ele, et un troisi\`eme format s'inserrerait de la
m\^eme fa\c{c}on.
\par
Pour les tableaux, il faudrait peut-\^etre repartir de la grammaire. Et surtout trouver une astuce
pour pouvoir tenir compte des encadrements et autres param\`etres de formatage.
\par
Les {\em fields} sont enti\`erement trait\'es dans le fichier {\tt rtf.fields.c}, qu'il suffirait
de completer par de nouvelles fonctions les traitant, ainsi que leur d\'etection au m\^eme point que
se fait celle des \'equations.



\newpage
\section{Fichiers sources et fonctions incluses.}


\subsubsection{ rtf.lex.c }
\begin{tabbing}
xxxxxxxxxxxxxx\=xxx\=\kill
Function name \>: \>{\tt valdefFD }\\
Description   \>: \>\begin{minipage}[t]{10cm}Attribue les valeurs par defaut aux differents champs 
	de formatage du document \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt puretext }\\
Description   \>: \>\begin{minipage}[t]{10cm}Lorsque l'on trouve une chaine de caract\`eres pure, il faut 
enlever les 
  retours \`a la ligne. En effet WORD coupe les lignes trop longues en plein milieu des mots !!
  De m\^eme, il y a des caract\`eres ASCII 7 bits que \LaTeX\ consid\`ere comme des mots de commande. Il faut les 
  transformer dans son propre format. Ceci ne peut etre fait \`a l'interieur de la grammaire, car 
  le texte 7 bits est un token \`a part enti\`ere. \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt getcode }\\
Description   \>: \>\begin{minipage}[t]{10cm}A partir de la chaine de caract\`eres d'un mot de commande 
renvoie son type et
  l\`eve un flag en cas de non reconnaissance.  \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt Avance\_Champ }\\
Description   \>: \>\begin{minipage}[t]{10cm}Avance tant que le champ \`a ignorer n'est pas termin\'e  
\end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt Avance\_Sauve\_Champ }\\
Description   \>: \>\begin{minipage}[t]{10cm}Avance tant que le champ \`a ignorer n'est pas termin\'e et 
le sauve dans un fichier auxiliaire  \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt Avance\_Sauve\_ChampMAC }\\
Description   \>: \>\begin{minipage}[t]{10cm}Avance tant que le champ \`a ignorer n'est pas termin\'e et 
le sauve dans un fichier auxiliaire.
			Mais pour le MAC.  \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt yylex }\\
Description   \>: \>\begin{minipage}[t]{10cm}Analyseur Lexical d'un fichier RTF. Fournit les Tokens \`a 
yyparse.  \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt yyerror }\\
Description   \>: \>\begin{minipage}[t]{10cm}Fonction de traitement des erreurs. Elle est apell\'ee 
automatiquement par yyparse,
		gener\'ee par Bision, lorsqu'une erreur s'est produite. Si on est au sein de l'ent\^ete, 
on positionne le flag de
		pr\'esence de \LaTeX . Si on est dans le corps du texte, on positionne le flag d'Erreur, 
pour que l'analyseur 
		lexical ignore tout jusqu'au debut du prochain paragraphe.  \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt main }\\
Description   \>: \>\begin{minipage}[t]{10cm}Fonction Principale: Analyse les param\`etres, ouvre les 
flux, et apelle yyparse(). \end{minipage}\\
\end{tabbing}


\subsubsection{ rtf.formule.c }
\begin{tabbing}
xxxxxxxxxxxxxx\=xxx\=\kill
Function name \>: \>{\tt moulineFormule }\\
Description   \>: \>\begin{minipage}[t]{10cm}Apr\`es d\'etection d'une formule, on la mouline de facon \`a rectifier les
                      absurdit\'es de formatage de RTF-Fields. \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt moulineFormuleMAC }\\
Description   \>: \>\begin{minipage}[t]{10cm}Apr\`es detection d'une formule MAC, on la mouline de facon \`a rectifier les
                      absurdit\'es de formatage de RTF-Fields. Mais pour le Mac.\end{minipage}\\
\end{tabbing}


\subsubsection{ rtf.fonts.c }
\begin{tabbing}
xxxxxxxxxxxxxx\=xxx\=\kill
Function name \>: \>{\tt nouvfonte }\\
Description   \>: \>\begin{minipage}[t]{10cm}Cr\'ee un nouveau maillon avec la description d'une fonte  \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt cherchefonte }\\
Description   \>: \>\begin{minipage}[t]{10cm}A partir du num\'ero de fonte, cherche une fonte donn\'ee. \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt parcoursfontes }\\
Description   \>: \>\begin{minipage}[t]{10cm}fonction de debuggage. \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt chercheEqTeX }\\
Description   \>: \>\begin{minipage}[t]{10cm}Cherche un equivalent \LaTeX\ pour un nom de fonte RTF \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt EqTeXTaille }\\
Description   \>: \>\begin{minipage}[t]{10cm}D\'etermine la taille de police \`a utiliser, \`a partir de la donn\'ee RTF, 
                      et retourne la chaine de caract\`eres \'equivalente TeX. \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt printSymbol }\\
Description   \>: \>\begin{minipage}[t]{10cm}Imprime un Symbole, en fonction de l'environnement dans lequel on se trouve. \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt printText }\\
Description   \>: \>\\
%**************************************************************************************************
Function name \>: \>{\tt printApostrophe }\\
Description   \>: \>\\
\end{tabbing}



\subsubsection{ rtf.context.c }
\begin{tabbing}
xxxxxxxxxxxxxx\=xxx\=\kill
Function name \>: \>{\tt nouvcontext }\\
Description   \>: \>\begin{minipage}[t]{10cm}Cr\'ee un nouveau maillon contexte \`a partir de sa description et retourne un
                      pointeur sur ce maillon \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt contextback }\\
Description   \>: \>\\
%**************************************************************************************************
Function name \>: \>{\tt parcourscontexts }\\
Description   \>: \>\begin{minipage}[t]{10cm}Parcours de la liste chain\'ee de contextes. (Debuggage); \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt endkeepcontext }\\
Description   \>: \>\begin{minipage}[t]{10cm}Termine le contexte courrant mais le garde en tant que contexte courrant.
                      Utile pour les Tableaux, car \LaTeX\ impose de terminer les environnements
                      avant de sortir de la minipage, alors que RTF ne le fait pas.
                      A utiliser suivi immediatement de showcontext... \end{minipage}\\
%**************************************************************************************************
Function name \>: \>{\tt showcontext }\\
Description   \>: \>\begin{minipage}[t]{10cm}Exprime les caracteristiques du contexte courrant. A utiliser en particulier
                      pour les tableaux apr\`es endkeepcontext \end{minipage}\\

\end{tabbing}


\subsubsection{ rtf.ascii }
Ce fichier contient les tables de correspondance ASCII entre MAC, PC et \LaTeX .



\subsubsection{ rtf.fields.c }
\begin{tabbing}
xxxxxxxxxxxxxx\=xxx\=\kill
Function name \>: \>{\tt filtrefields }\\
Description   \>: \>\begin{minipage}[t]{10cm}Recup\`ere un champ field et le pr\'epare \`a \^etre analyse par yylex \end{minipage}\\
\end{tabbing}



\subsubsection{ rtf.output }
Le fichier {\tt rtf.output} est g\'en\'er\'e par Bison si on l'ex\'ecute avec l'option {\tt -v}.
Il d\'etaille l'\'etat de la grammaire et de ses r\`egles. Les conflicts qui existent actuellement
sont dus au fait que la grammaire RTF n'est pas LALR1. Ils ne devraient pas causer de probl\`eme.
Lors de l'impl\'ementattion de nouvelles r\`egles, il faudra veiller \`a ce que ce nombre n'augmente
pas.


\subsubsection{ rtf.tab.c }
Il s'agit du fichier g\'en\'er\'e par Bison, et qui sera lui compil\'e pour obtenir l'ex\'ecutable.
Pour le compiler:
\begin{quote}
	$>$cc -o w2latex rtf.tab.c
\end{quote}
et \c{c}a y est!


\subsubsection{ rtf.motcom.h }
Ce fichier contient la table de correspondance entre les mots de commande RTF et les tokens. Il s'agit des
m\^emes mots, mais en majuscules. Lors de l'impl\'ementation de nouvelles r\`egles demandant de nouveaux
tokens, il ne faut pas oublier de les r\'epertorier ici (et d'augmenter le nombre des \'el\'ements du tableau
d\'efini dans l'ent\^ete du fichier.



\newpage
\section{Documents de R\'ef\'erence}

\begin{itemize}
\item BISON: The Yacc compatible Parser Generator
\begin{quote} 
	Bison Version 1.20\\
	By Charles Donnelly and Richard Stallman
\end{quote}
\item A Gentle Introduction to \TeX .
\begin{quote}
	Michael Doob\\
	University of Manitoba
\end{quote}
\item Notes de Cous \LaTeX .
\begin{quote}
	Claude Gomez\\
	INRIA
\end{quote}
\item Essential \LaTeX .
\begin{quote}
	Jon Warbrick
\end{quote}
\item \LaTeX : user's guide and Reference Manual
\begin{quote}
	Leslie Lamport\\
	Addison-Wesley
\end{quote}
\item Microsoft Rich Text Format (RTF) Specification
\begin{quote}
	Microsoft\copyright \\
	Application Note\\
	RTF VErsion 1.3 1994
\end{quote}
\item Fields Reference
\begin{quote}
	Microsoft\copyright\ Word\copyright \\
	Version 6.0
\end{quote}
\end{itemize}







\newpage
\section{Disclaimer}
Ce document se rapporte au programme W2\LaTeX , r\'ealis\'e par Javier 
Garmendia\footnote{jgarmend@cyberspace.org}, et a \'et\'e r\'ealis\'e pour le Centre International de
Rencontres Math\'ematiques de Luminy (Marseille), sous la direction de Jean-Louis 
Maltret\footnote{jlm@cirm.univ-mrs.fr}.

\end{document}