/*
================================================================================
  RPL/2 (R) version 4.0.24
  Copyright (C) 1989-2011 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"
#include "tex-conv.h"


/*
================================================================================
  Fonction créant un fichier d'impression au format TeX
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

file *
creation_fichier_tex(struct_processus *s_etat_processus)
{
	file				*fichier_impression;

	unsigned char		*nom_fichier_temporaire;

	if ((nom_fichier_temporaire = creation_nom_fichier(s_etat_processus,
			(*s_etat_processus).chemin_fichiers_temporaires)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if ((nom_fichier_temporaire = realloc(nom_fichier_temporaire,
			(strlen(nom_fichier_temporaire) + 5) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	strcat(nom_fichier_temporaire, ".tex");
	(*s_etat_processus).nom_fichier_impression = nom_fichier_temporaire;

	if ((fichier_impression = fopen(nom_fichier_temporaire, "w+")) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\documentclass[%s,%s]{%s}\n\n",
			(*s_etat_processus).format_papier, ds_tex_taille_corps,
			ds_tex_classe_document) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}


	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage[%s]{fontenc}\n", ds_tex_encodage_1) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage[%s]{inputenc}\n", ds_tex_encodage_2) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage[%s]{babel}\n\n", ds_tex_langue) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage{latexsym}\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage[dvips]{color}\n\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage{amsmath}\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage{amsfonts}\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\usepackage{amssymb}\n\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\title{Fichier d'impression}\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\author{RPL/2 Version %s}\n", d_version_rpl) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression, "\\date{}\n\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\begin{document}\n\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\thispagestyle{%s}\n", ds_tex_style) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\pagestyle{%s}\n\n", ds_tex_style) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return(NULL);
	}

	return(fichier_impression);
}


/*
================================================================================
  Fonction 'formateur_tex'
================================================================================
  Entrées : environnement 'V' verbatim, 'N' normal
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
formateur_tex(struct_processus *s_etat_processus, struct_objet *s_objet,
		unsigned char environnement)
{
	file				*fichier_impression;

	/*
	 * Création, le cas échéant, du fichier d'impression
	 */

	if ((*s_etat_processus).nom_fichier_impression == NULL)
	{
		if ((fichier_impression = creation_fichier_tex(s_etat_processus))
				== NULL)
		{
			return;
		}
	}
	else
	{
		if ((fichier_impression = fopen((*s_etat_processus)
				.nom_fichier_impression, "a")) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression d'un entier binaire
	 */

	if ((*s_objet).type == BIN)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression, "$$") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression, "$$\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression des chaînes de caractères
	 */

	else if ((*s_objet).type == CHN)
	{
		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression, "\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression d'un nombre
	 */

	else if (((*s_objet).type == CPL) ||
			((*s_objet).type == INT) ||
			((*s_objet).type == REL))
	{
		if (tex_fprintf(s_etat_processus, fichier_impression, "$$") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
		
		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression, "$$\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression d'un nom
	 */

	else if ((*s_objet).type == NOM)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\begin{center}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{center}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression d'un vecteur
	 */

	else if (((*s_objet).type == VCX) ||
			((*s_objet).type == VIN) ||
			((*s_objet).type == VRL))
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\begin{equation}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\nonumber\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{equation}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression d'une matrice d'entiers
	 */

	else if (((*s_objet).type == MIN) ||
			((*s_objet).type == MRL) ||
			((*s_objet).type == MCX))
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\begin{equation}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);
		
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\nonumber\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{equation}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression d'une expression RPN ou d'une liste
	 */

	else if (((*s_objet).type == RPN) ||
			((*s_objet).type == LST))
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\begin{center}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{center}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Impression d'une expression algébrique
	 */

	else if ((*s_objet).type == ALG)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\begin{equation}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				s_objet, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\nonumber\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{equation}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Objet invalide
	 */

	else
	{
		if (fclose(fichier_impression) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	if (fclose(fichier_impression) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	return;
}


/*
================================================================================
  Formatage des fichiers TeX au niveau des types d'objets élémentaires
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
formateur_elementaire_tex(struct_processus *s_etat_processus,
		file *fichier_impression, struct_objet *s_objet,
		unsigned char environnement)
{
	logical1						fraction;
	logical1						multiplication;
	logical1						puissance;

	struct_liste_chainee			*l_element_courant;
	struct_liste_chainee			*l_liste1;
	struct_liste_chainee			*l_liste2;

	struct_objet					*s_copie_objet;
	struct_objet					s_objet_elementaire;
	struct_objet					*s_sous_objet;
	struct_objet					*s_sous_objet_1;
	struct_objet					*s_sous_objet_2;

	unsigned char					base;
	unsigned char					*chaine;
	unsigned char					*chaine_majuscule;
	unsigned char					*chaine_parametre;
	unsigned char					*chaine_sauvegarde;
	unsigned char					*instruction_courante;
	unsigned char					*instruction_majuscule;
	unsigned char					instruction_valide;
	unsigned char					*ligne;
	unsigned char					*ptre;
	unsigned char					*ptrl;
	unsigned char					test_instruction;
	unsigned char					*tampon;

	unsigned long					i;
	unsigned long					j;
	unsigned long					niveau;
	unsigned long					nombre_arguments;

	/*
	 * Entier binaire
	 */

	if ((*s_objet).type == BIN)
	{
		if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		base = ligne[strlen(ligne) - 1];
		ligne[strlen(ligne) - 1] = d_code_fin_chaine;

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\#\\,%s\\text{%c}", &(ligne[1]), base) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		free(ligne);
	}

	/*
	 * Chaîne de caractères
	 */

	else if ((*s_objet).type == CHN)
	{
		if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (environnement == 'N')
		{
			correction_formateur_tex(s_etat_processus, &ligne);
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		free(ligne);
	}

	/*
	 * Nom
	 */

	else if ((*s_objet).type == NOM)
	{
		if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (environnement == 'N')
		{
			correction_formateur_tex(s_etat_processus, &ligne);
		}

		test_instruction = (*s_etat_processus).test_instruction;
		instruction_valide = (*s_etat_processus).instruction_valide;
		instruction_courante = (*s_etat_processus).instruction_courante;

		(*s_etat_processus).test_instruction = 'Y';
		(*s_etat_processus).instruction_courante =
				(*((struct_nom *) (*s_objet).objet)).nom;

		analyse(s_etat_processus, NULL);

		if ((*s_etat_processus).instruction_valide == 'Y')
		{
			if ((instruction_majuscule = conversion_majuscule(
					(*s_etat_processus).instruction_courante)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			if (strcmp(instruction_majuscule, "PI") == 0)
			{
				if (tex_fprintf(s_etat_processus, fichier_impression,
						"$\\pi$") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}
			}
			else
			{
				if (tex_fprintf(s_etat_processus, fichier_impression,
						"\\textrm{%s}", ligne) < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}
			}

			free(instruction_majuscule);
		}
		else
		{
			if (tex_fprintf(s_etat_processus, fichier_impression,
					"\\textit{%s}", ligne) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		(*s_etat_processus).instruction_courante = instruction_courante;
		(*s_etat_processus).test_instruction = test_instruction;
		(*s_etat_processus).instruction_valide = instruction_valide;

		free(ligne);
	}

	/*
	 * Nombre complexe
	 */

	else if ((*s_objet).type == CPL)
	{
		s_objet_elementaire.type = REL;

		if ((s_objet_elementaire.objet = malloc(sizeof(real8))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "\\left(") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		(*((real8 *) (s_objet_elementaire.objet))) = (*((complex16 *)
				(*s_objet).objet)).partie_reelle;

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				&s_objet_elementaire, environnement);

		(*((real8 *) (s_objet_elementaire.objet))) = (*((complex16 *)
				(*s_objet).objet)).partie_imaginaire;

		if (test_cfsf(s_etat_processus, 48) == d_vrai)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression, ".\\,") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}
		else
		{
			if (tex_fprintf(s_etat_processus, fichier_impression, ",") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		formateur_elementaire_tex(s_etat_processus, fichier_impression,
				&s_objet_elementaire, environnement);

		if (tex_fprintf(s_etat_processus, fichier_impression, "\\right)") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		free(s_objet_elementaire.objet);
	}

	/*
	 * Entier
	 */

	else if ((*s_objet).type == INT)
	{
		if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		free(ligne);
	}

	/*
	 * Matrice de complexes
	 */

	else if ((*s_objet).type == MCX)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\left(\\begin{array}{") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	
		for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
				.nombre_colonnes; i++)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if ((s_objet_elementaire.objet = (complex16 *) malloc(
				sizeof(complex16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		s_objet_elementaire.type = CPL;

		for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
				i++)
		{
			for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
					.nombre_colonnes; j++)
			{
				(*((complex16 *) (s_objet_elementaire.objet))).partie_reelle =
						((complex16 **) (*((struct_matrice *)
						(*s_objet).objet)).tableau)[i][j].partie_reelle;
				(*((complex16 *) (s_objet_elementaire.objet)))
						.partie_imaginaire = ((complex16 **)
						(*((struct_matrice *) (*s_objet).objet)).tableau)[i][j]
						.partie_imaginaire;

				formateur_elementaire_tex(s_etat_processus, fichier_impression,
						&s_objet_elementaire, environnement);

				if (j == ((*((struct_matrice *) (*s_objet).objet))
						.nombre_colonnes - 1))
				{
					if (tex_fprintf(s_etat_processus, fichier_impression,
							" \\\\\n") < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
				else
				{
					if (tex_fprintf(s_etat_processus, fichier_impression,
							" & ") < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
			}
		}

		free(s_objet_elementaire.objet);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{array}\\right)\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Matrice d'entiers
	 */

	else if ((*s_objet).type == MIN)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\left(\\begin{array}{") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	
		for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
				.nombre_colonnes; i++)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if ((s_objet_elementaire.objet = (integer8 *) malloc(sizeof(integer8)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		s_objet_elementaire.type = INT;

		for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
				i++)
		{
			for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
					.nombre_colonnes; j++)
			{
				(*((integer8 *) (s_objet_elementaire.objet))) =
						((integer8 **) (*((struct_matrice *)
						(*s_objet).objet)).tableau)[i][j];

				formateur_elementaire_tex(s_etat_processus, fichier_impression,
						&s_objet_elementaire, environnement);

				if (j == ((*((struct_matrice *) (*s_objet).objet))
						.nombre_colonnes - 1))
				{
					if (tex_fprintf(s_etat_processus, fichier_impression,
							" \\\\\n") < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
				else
				{
					if (tex_fprintf(s_etat_processus, fichier_impression,
							" & ") < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
			}
		}

		free(s_objet_elementaire.objet);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{array}\\right)\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Matrice de réels
	 */

	else if ((*s_objet).type == MRL)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\left(\\begin{array}{") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	
		for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
				.nombre_colonnes; i++)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression, "c") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if ((s_objet_elementaire.objet = (real8 *) malloc(sizeof(real8)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		s_objet_elementaire.type = REL;

		for(i = 0; i < (*((struct_matrice *) (*s_objet).objet)).nombre_lignes;
				i++)
		{
			for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
					.nombre_colonnes; j++)
			{
				(*((real8 *) (s_objet_elementaire.objet))) =
						((real8 **) (*((struct_matrice *)
						(*s_objet).objet)).tableau)[i][j];

				formateur_elementaire_tex(s_etat_processus, fichier_impression,
						&s_objet_elementaire, environnement);

				if (j == ((*((struct_matrice *) (*s_objet).objet))
						.nombre_colonnes - 1))
				{
					if (tex_fprintf(s_etat_processus, fichier_impression,
							" \\\\\n") < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
				else
				{
					if (tex_fprintf(s_etat_processus, fichier_impression,
							" & ") < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
			}
		}

		free(s_objet_elementaire.objet);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{array}\\right)\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Réel
	 */

	else if ((*s_objet).type == REL)
	{
		if ((ligne = formateur(s_etat_processus, 0, s_objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		for(i = 0; i < strlen(ligne); i++)
		{
			switch(ligne[i])
			{
				case 'e' :
				case 'E' :
				{
					if ((tampon = (unsigned char *) malloc((strlen(ligne)
							+ 12) * sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					strncpy(tampon, ligne, i);
					strcpy(&(tampon[i]), "\\times 10^{");
					strcat(tampon, &(ligne[++i]));
					strcat(tampon, "}");
					i += 10;

					free(ligne);
					ligne = tampon;

					break;
				}

				case ',' :
				{
					if ((tampon = (unsigned char *) malloc((strlen(ligne)
							+ 3) * sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					strncpy(tampon, ligne, ++i);
					strcpy(&(tampon[i]), "\\!");
					strcat(tampon, &(ligne[i]));
					i += 2;

					free(ligne);
					ligne = tampon;

					break;
				}
			}
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "%s", ligne) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
		
		free(ligne);
	}

	/*
	 * Vecteur de complexes
	 */

	else if ((*s_objet).type == VCX)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\left(\\begin{array}{c}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if ((s_objet_elementaire.objet = (complex16 *) malloc(
				sizeof(complex16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		s_objet_elementaire.type = CPL;

		for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
		{
			(*((complex16 *) (s_objet_elementaire.objet))).partie_reelle =
					((complex16 *) (*((struct_vecteur *)
					(*s_objet).objet)).tableau)[i].partie_reelle;
			(*((complex16 *) (s_objet_elementaire.objet))).partie_imaginaire =
					((complex16 *) (*((struct_vecteur *)
					(*s_objet).objet)).tableau)[i].partie_imaginaire;

			formateur_elementaire_tex(s_etat_processus, fichier_impression,
					&s_objet_elementaire, environnement);

			if (tex_fprintf(s_etat_processus, fichier_impression,
					" \\\\\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		free(s_objet_elementaire.objet);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{array}\\right)\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Vecteur d'entiers
	 */

	else if ((*s_objet).type == VIN)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\left(\\begin{array}{c}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if ((s_objet_elementaire.objet = (integer8 *) malloc(sizeof(integer8)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		s_objet_elementaire.type = INT;

		for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
		{
			(*((integer8 *) (s_objet_elementaire.objet))) =
					((integer8 *) (*((struct_vecteur *)
					(*s_objet).objet)).tableau)[i];

			formateur_elementaire_tex(s_etat_processus, fichier_impression,
					&s_objet_elementaire, environnement);

			if (tex_fprintf(s_etat_processus, fichier_impression,
					" \\\\\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		free(s_objet_elementaire.objet);

		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\end{array}\\right)\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Vecteur de réels
	 */

	else if ((*s_objet).type == VRL)
	{
		if (tex_fprintf(s_etat_processus, fichier_impression,
				"\\left(\\begin{array}{c}\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if ((s_objet_elementaire.objet = (real8 *) malloc(sizeof(real8)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		s_objet_elementaire.type = REL;

		for(i = 0; i < (*((struct_vecteur *) (*s_objet).objet)).taille; i++)
		{
			(*((real8 *) (s_objet_elementaire.objet))) =
					((real8 *) (*((struct_vecteur *)
					(*s_objet).objet)).tableau)[i];

			formateur_elementaire_tex(s_etat_processus, fichier_impression,
					&s_objet_elementaire, environnement);

			if (tex_fprintf(s_etat_processus, fichier_impression,
					" \\\\\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		free(s_objet_elementaire.objet);

		if (tex_fprintf(s_etat_processus, fichier_impression,
					"\\end{array}\\right)\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	/*
	 * Fonction
	 */

	else if ((*s_objet).type == FCT)
	{
		if ((strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
				"+") == 0) || (strcmp((*((struct_fonction *) (*s_objet).objet))
				.nom_fonction, "-") == 0) || (strcmp((*((struct_fonction *)
				(*s_objet).objet)).nom_fonction, "/") == 0))
		{
			if (tex_fprintf(s_etat_processus, fichier_impression, "$%s$",
					(*((struct_fonction *) (*s_objet).objet)).nom_fonction) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}
		else if (strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
				"*") == 0)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression,
					"$\\times$") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}
		else if (strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
				"^") == 0)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression,
					"$\\,\\hat{}\\,$") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}
		else if (strcmp((*((struct_fonction *) (*s_objet).objet)).nom_fonction,
				"->") == 0)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression,
					"$\\rightarrow$") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}
		else
		{
			if ((ligne = (unsigned char *) malloc((strlen((*((struct_fonction *)
					(*s_objet).objet)).nom_fonction) + 1) *
					sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy(ligne, (*((struct_fonction *) (*s_objet).objet))
					.nom_fonction);

			correction_formateur_tex(s_etat_processus, &ligne);
			
			if (tex_fprintf(s_etat_processus, fichier_impression, ligne) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}

			free(ligne);
		}
	}

	/*
	 * Expression RPN ou liste
	 */

	else if (((*s_objet).type == RPN) ||
			((*s_objet).type == LST))
	{
		if ((*s_objet).type == LST)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression,
					"\\begin{equation}\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}

			if (tex_fprintf(s_etat_processus, fichier_impression,
					"\\left\\{\\text{%%\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		l_element_courant = (struct_liste_chainee *) (*s_objet).objet;

		while(l_element_courant != NULL)
		{
			if (((*(*l_element_courant).donnee).type == INT) ||
					((*(*l_element_courant).donnee).type == REL) ||
					((*(*l_element_courant).donnee).type == CPL) ||
					((*(*l_element_courant).donnee).type == VIN) ||
					((*(*l_element_courant).donnee).type == VRL) ||
					((*(*l_element_courant).donnee).type == MIN) ||
					((*(*l_element_courant).donnee).type == MRL) ||
					((*(*l_element_courant).donnee).type == MCX) ||
					((*(*l_element_courant).donnee).type == BIN))
			{
				if (tex_fprintf(s_etat_processus, fichier_impression, "$") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				formateur_elementaire_tex(s_etat_processus, fichier_impression,
						(*l_element_courant).donnee, environnement);

				if (tex_fprintf(s_etat_processus, fichier_impression,
						"$%%") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}
			}
			else
			{
				formateur_elementaire_tex(s_etat_processus, fichier_impression,
						(*l_element_courant).donnee, environnement);
			}

			if (tex_fprintf(s_etat_processus, fichier_impression, "\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if ((*s_objet).type == LST)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression,
					"}\\right\\}\\nonumber\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}

			if (tex_fprintf(s_etat_processus, fichier_impression,
					"\\end{equation}\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}
	}

	/*
	 * Expression algébrique
	 */

	else if ((*s_objet).type == ALG)
	{
		if ((s_copie_objet = copie_objet(s_etat_processus, s_objet, 'N'))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		l_element_courant = (struct_liste_chainee *) (*s_copie_objet).objet;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type == FCT)
			{
				if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
						.donnee).objet)).nom_fonction, "<<") != 0) &&
						(strcmp((*((struct_fonction *) (*(*l_element_courant)
						.donnee).objet)).nom_fonction, ">>") != 0))
				{
					if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
							.donnee).objet)).nom_fonction, "+") == 0) ||
							(strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet))
							.nom_fonction, "-") == 0) || (strcmp(
							(*((struct_fonction *) (*(*l_element_courant)
							.donnee).objet)).nom_fonction, "*") == 0) ||
							(strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"/") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"^") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"<") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"=") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							">") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"==") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"<>") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"<=") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"=<") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							">=") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"=>") == 0))
					{
						chaine_sauvegarde = (*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction;

						fraction = d_faux;
						multiplication = d_faux;
						puissance = d_faux;

						if ((strcmp(chaine_sauvegarde, "+") == 0) ||
								(strcmp(chaine_sauvegarde, "-") == 0) ||
								(strcmp(chaine_sauvegarde, "=") == 0) ||
								(strcmp(chaine_sauvegarde, "==") == 0))
						{
							/*
							 * Il n'y a rien à faire
							 */
						}
						else if (strcmp(chaine_sauvegarde, "*") == 0)
						{
							if (((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction = malloc(
									8 * sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return;
							}

							strcpy((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction,
									"\\times ");
							free(chaine_sauvegarde);

							multiplication = d_vrai;
						}
						else if (strcmp(chaine_sauvegarde, "/") == 0)
						{
							fraction = d_vrai;
						}
						else if (strcmp(chaine_sauvegarde, "^") == 0)
						{
							puissance = d_vrai;
						}
						else if ((strcmp(chaine_sauvegarde, "<=") == 0) ||
								(strcmp(chaine_sauvegarde, "=<") == 0))
						{
							if (((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction = malloc(
									11 * sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return;
							}

							strcpy((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction,
									"\\leqslant ");
							free(chaine_sauvegarde);
						}
						else if ((strcmp(chaine_sauvegarde, ">=") == 0) ||
								(strcmp(chaine_sauvegarde, "=>") == 0))
						{
							if (((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction = malloc(
									11 * sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return;
							}

							strcpy((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction,
									"\\geqslant ");
							free(chaine_sauvegarde);
						}
						else if (strcmp(chaine_sauvegarde, "<>") == 0)
						{
							if (((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction = malloc(
									6 * sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return;
							}

							strcpy((*((struct_fonction *) (*(*l_element_courant)
									.donnee).objet)).nom_fonction,
									"\\neq ");
							free(chaine_sauvegarde);
						}

						if (depilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), &s_sous_objet_2) == d_erreur)
						{
							return;
						}

						if (depilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), &s_sous_objet_1) == d_erreur)
						{
							return;
						}

						if ((s_sous_objet = allocation(s_etat_processus, CHN))
								== NULL)
						{
							return;
						}

						if (fraction == d_vrai)
						{
							if (((*s_sous_objet).objet = (void *)
									malloc((strlen(
									(unsigned char *) (*s_sous_objet_1).objet) +
									strlen((unsigned char *)
									(*s_sous_objet_2).objet) + 12) *
									sizeof(unsigned char))) == NULL)
							{
								return;
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"{\\frac{%s}{%s}}", (unsigned char *)
									(*s_sous_objet_1).objet, (unsigned char *)
									(*s_sous_objet_2).objet);
						}
						else if (puissance == d_vrai)
						{
							if (((unsigned char *)
									strstr((unsigned char *) (*s_sous_objet_1)
									.objet, "{\\frac{")) == ((unsigned char *)
									(*s_sous_objet_1).objet))
							{
								niveau = 0;

								for(i = 1; i < (strlen((unsigned char *)
										(*s_sous_objet_1).objet) - 1); i++)
								{
									if (((unsigned char *) (*s_sous_objet_1)
											.objet)[i] == '{')
									{
										niveau++;
									}
									else if (((unsigned char *)
											(*s_sous_objet_1).objet)[i] == '}')
									{
										niveau--;

										if (niveau == 0)
										{
											break;
										}
									}
								}

								if (niveau == 0)
								{
									sprintf((unsigned char *) (*s_sous_objet_1)
											.objet, "%s", &(((unsigned char *) 
											(*s_sous_objet_1).objet)[1]));
									((unsigned char *) (*s_sous_objet_1).objet)
											[strlen((unsigned char *)
											(*s_sous_objet_1).objet) - 1] =
											d_code_fin_chaine;
								}
							}

							chaine_parametre = (unsigned char *)
									(*s_sous_objet_1).objet;
							conversion_element_tex(&chaine_parametre, "^");

							if ((*s_sous_objet_1).objet == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return;
							}

							if (((*s_sous_objet).objet = (void *)
									malloc((strlen(
									(unsigned char *) (*s_sous_objet_1).objet) +
									strlen((unsigned char *)
									(*s_sous_objet_2).objet) + 8) *
									sizeof(unsigned char))) == NULL)
							{
								return;
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"{{%s}^{%s}}",
									(unsigned char *) (*s_sous_objet_1).objet,
									(unsigned char *) (*s_sous_objet_2).objet);
						}
						else if (multiplication == d_vrai)
						{
							chaine_parametre = (unsigned char *)
									(*s_sous_objet_1).objet;
							conversion_element_tex(&chaine_parametre,
									(*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction);

							if ((*s_sous_objet_1).objet == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return;
							}

							chaine_parametre = (unsigned char *)
									(*s_sous_objet_2).objet;
							conversion_element_tex(&chaine_parametre,
									(*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction);

							if ((*s_sous_objet_2).objet == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return;
							}

							if ((((unsigned char *) (*s_sous_objet_2)
									.objet)[0] == '+') || (((unsigned char *)
									(*s_sous_objet_2).objet)[0] == '-'))
							{
								if (((*s_sous_objet).objet = (void *)
										malloc((strlen((unsigned char *)
										(*s_sous_objet_1).objet) +
										strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) +
										strlen((unsigned char *)
										(*s_sous_objet_2).objet) + 14) *
										sizeof(unsigned char))) == NULL)
								{
									return;
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"%s%s\\left(%s\\right)",
										(unsigned char *) (*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}
							else
							{
								if (((*s_sous_objet).objet = (void *)
										malloc((strlen((unsigned char *)
										(*s_sous_objet_1).objet) +
										strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) +
										strlen((unsigned char *)
										(*s_sous_objet_2).objet) + 1) *
										sizeof(unsigned char))) == NULL)
								{
									return;
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"%s%s%s", (unsigned char *)
										(*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}
						}
						else
						{
							if ((strcmp((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, "<") != 0) &&
									(strcmp((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, ">") != 0) &&
									(strcmp((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, "=") != 0) &&
									(strcmp((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, "==") != 0) &&
									(strcmp((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, "\\geqslant ") != 0) &&
									(strcmp((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, "\\leqslant ") != 0))
							{
								chaine_parametre = (unsigned char *)
										(*s_sous_objet_1).objet;
								conversion_element_tex(&chaine_parametre,
										(*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction);

								if ((*s_sous_objet_1).objet == NULL)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_allocation_memoire;
									return;
								}

								chaine_parametre = (unsigned char *)
										(*s_sous_objet_2).objet;
								conversion_element_tex(&chaine_parametre,
										(*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction);

								if ((*s_sous_objet_2).objet == NULL)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_allocation_memoire;
									return;
								}
							}

							if ((((unsigned char *) (*s_sous_objet_2)
									.objet)[0] == '+') || (((unsigned char *)
									(*s_sous_objet_2).objet)[0] == '-'))
							{
								if (((*s_sous_objet).objet = (void *)
										malloc((strlen((unsigned char *)
										(*s_sous_objet_1).objet) +
										strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) +
										strlen((unsigned char *)
										(*s_sous_objet_2).objet) + 18) *
										sizeof(unsigned char))) == NULL)
								{
									return;
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"{%s}%s{\\left(%s\\right)}",
										(unsigned char *) (*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}
							else
							{
								if (((*s_sous_objet).objet = (void *)
										malloc((strlen((unsigned char *)
										(*s_sous_objet_1).objet) +
										strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) +
										strlen((unsigned char *)
										(*s_sous_objet_2).objet) + 5) *
										sizeof(unsigned char))) == NULL)
								{
									return;
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"{%s}%s{%s}", (unsigned char *)
										(*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}
						}

						liberation(s_etat_processus, s_sous_objet_1);
						liberation(s_etat_processus, s_sous_objet_2);

						if (empilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), s_sous_objet) == d_erreur)
						{
							return;
						}
					}
					else if (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"NOT") == 0)
					{
						if (depilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), &s_sous_objet_1) == d_erreur)
						{
							return;
						}

						if ((s_sous_objet = allocation(s_etat_processus, CHN))
								== NULL)
						{
							return;
						}

						if (((*s_sous_objet).objet = (unsigned char *) malloc(
								(strlen((unsigned char *) (*s_sous_objet_1)
								.objet) + 25) * sizeof(unsigned char))) ==
								NULL)
						{
							return;
						}

						sprintf((unsigned char *) (*s_sous_objet).objet,
								"\\text{%s}\\left(%s\\right)",
								(*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction, (unsigned char *)
								(*s_sous_objet_1).objet);

						liberation(s_etat_processus, s_sous_objet_1);

						if (empilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), s_sous_objet) == d_erreur)
						{
							return;
						}
					}
					else if ((strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"OR") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"XOR") == 0) || (strcmp((*((struct_fonction *)
							(*(*l_element_courant).donnee).objet)).nom_fonction,
							"AND") == 0))
					{
						if (depilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), &s_sous_objet_2) == d_erreur)
						{
							return;
						}

						if (depilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), &s_sous_objet_1) == d_erreur)
						{
							return;
						}

						if ((s_sous_objet = allocation(s_etat_processus, CHN))
								== NULL)
						{
							return;
						}

						if (((*s_sous_objet).objet = (void *) malloc((strlen(
								(unsigned char *) (*s_sous_objet_1).objet) +
								strlen((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction) + strlen((unsigned char *)
								(*s_sous_objet_2).objet) + 10) *
								sizeof(unsigned char))) == NULL)
						{
							return;
						}

						sprintf((unsigned char *) (*s_sous_objet).objet,
								"%s \\text{%s} %s", (unsigned char *)
							   	(*s_sous_objet_1)
								.objet, (*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction, (unsigned char *)
								(*s_sous_objet_2).objet);

						liberation(s_etat_processus, s_sous_objet_1);
						liberation(s_etat_processus, s_sous_objet_2);

						if (empilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), s_sous_objet) == d_erreur)
						{
							return;
						}
					}
					else
					{
						nombre_arguments = (*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nombre_arguments;

						if ((chaine = (unsigned char *)
								malloc(sizeof(unsigned char))) == NULL)
						{
							return;
						}
						
						chaine[0] = d_code_fin_chaine;

						for(i = 0; i < nombre_arguments; i++)
						{
							if ((nombre_arguments - i) > 1)
							{
								l_liste1 = (*s_etat_processus).l_base_pile;

								for(j = 2; j < (nombre_arguments - i); j++)
								{
									l_liste1 = (*l_liste1).suivant;
								}

								l_liste2 = (*l_liste1).suivant;
								(*l_liste1).suivant = (*l_liste2).suivant;
								(*l_liste2).suivant = (*s_etat_processus)
										.l_base_pile;
								(*s_etat_processus).l_base_pile = l_liste2;
							}
							
							if (depilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									&s_sous_objet) == d_erreur)
							{
								return;
							}

							chaine_sauvegarde = chaine;

							if (strlen(chaine_sauvegarde) == 0)
							{
								if ((chaine = (unsigned char *) malloc((strlen(
										(unsigned char *) (*s_sous_objet).objet)
										+ 1) * sizeof(unsigned char))) == NULL)
								{
									return;
								}

								sprintf(chaine, "%s", (unsigned char *)
										(*s_sous_objet).objet);
							}
							else
							{
								if ((chaine = (unsigned char *) malloc((strlen(
										chaine_sauvegarde) + 1 + strlen(
										(unsigned char *) (*s_sous_objet).objet)
										+ 1) * sizeof(unsigned char))) == NULL)
								{
									return;
								}

								sprintf(chaine, "%s,%s", chaine_sauvegarde,
										(unsigned char *) (*s_sous_objet)
										.objet);
							}

							free(chaine_sauvegarde);
							liberation(s_etat_processus, s_sous_objet);
						}

						chaine_sauvegarde = chaine;

						if ((chaine = (unsigned char *) malloc((strlen(
								(*((struct_fonction *) (*(*l_element_courant)
								.donnee).objet)).nom_fonction) + 20 +
								strlen(chaine_sauvegarde) + 1) *
								sizeof(unsigned char))) == NULL)
						{
							return;
						}

						sprintf(chaine, "\\text{%s}\\left(%s\\right)",
								(*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction, chaine_sauvegarde);
						free(chaine_sauvegarde);

						instruction_courante = (*s_etat_processus)
								.instruction_courante;
						test_instruction = (*s_etat_processus).test_instruction;
						instruction_valide = (*s_etat_processus)
								.instruction_valide;

						(*s_etat_processus).test_instruction = 'Y';
						(*s_etat_processus).instruction_courante =
								(*((struct_fonction *) (*(*l_element_courant)
								.donnee).objet)).nom_fonction;

						analyse(s_etat_processus, NULL);

						if ((*s_etat_processus).instruction_valide == 'Y')
						{
							for(i = 0; i < strlen(chaine); i++)
							{
								if ((chaine[i] >= 'A') && (chaine[i] <= 'Z'))
								{
									chaine[i] += ('a' - 'A');
								}
							}
						}

						(*s_etat_processus).instruction_courante =
								instruction_courante;
						(*s_etat_processus).test_instruction =
								instruction_valide;
						(*s_etat_processus).instruction_valide =
								instruction_valide;

						if ((s_sous_objet = allocation(s_etat_processus, CHN))
								== NULL)
						{
							return;
						}

						(*s_sous_objet).objet = (void *) chaine;

						if (empilement(s_etat_processus, &((*s_etat_processus)
								.l_base_pile), s_sous_objet) == d_erreur)
						{
							return;
						}
					}
				}
			}
			else
			{
				if ((s_sous_objet = allocation(s_etat_processus, CHN))
						== NULL)
				{
					return;
				}

				if (((*s_sous_objet).objet = (void *) formateur(
						s_etat_processus, 0, 
						(*l_element_courant).donnee)) == NULL)
				{
					return;
				}

				if ((*(*l_element_courant).donnee).type == NOM)
				{
					chaine_sauvegarde = (unsigned char *) (*s_sous_objet).objet;

					if (((*s_sous_objet).objet = malloc((strlen(
							chaine_sauvegarde) - 1) *
							sizeof(unsigned char))) == NULL)
					{
						return;
					}

					ptrl = chaine_sauvegarde;
					ptre = (unsigned char *) (*s_sous_objet).objet;

					for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
							i--, *ptre++ = *ptrl++);

					(*ptre) = d_code_fin_chaine;

					free(chaine_sauvegarde);

					chaine_majuscule = conversion_majuscule((*((struct_nom *)
							(*(*l_element_courant).donnee).objet)).nom);

					if (strcmp(chaine_majuscule, "PI") == 0)
					{
						free((unsigned char *) (*s_sous_objet).objet);

						if (((*s_sous_objet).objet =
								malloc(5 * sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return;
						}

						strcpy((unsigned char *) (*s_sous_objet).objet,
								"\\pi ");
					}
					else if (strcmp((*((struct_nom *) (*(*l_element_courant)
							.donnee).objet)).nom, "i") == 0)
					{
						free((unsigned char *) (*s_sous_objet).objet);

						if (((*s_sous_objet).objet =
								malloc(9 * sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return;
						}

						strcpy((unsigned char *) (*s_sous_objet).objet,
								"\\text{i}");
					}
					else if (strcmp((*((struct_nom *) (*(*l_element_courant)
							.donnee).objet)).nom, "e") == 0)
					{
						free((unsigned char *) (*s_sous_objet).objet);

						if (((*s_sous_objet).objet =
								malloc(9 * sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return;
						}

						strcpy((unsigned char *) (*s_sous_objet).objet,
								"\\text{e}");
					}

					free(chaine_majuscule);
				}

				if (empilement(s_etat_processus, &((*s_etat_processus)
						.l_base_pile), s_sous_objet) == d_erreur)
				{
					return;
				}
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				&s_sous_objet) == d_erreur)
		{
			return;
		}

		if (tex_fprintf(s_etat_processus, fichier_impression, "%s",
				(unsigned char *) (*s_sous_objet).objet) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		liberation(s_etat_processus, s_sous_objet);
		liberation(s_etat_processus, s_copie_objet);
	}

	return;
}


/*
================================================================================
  Echappement des caractères spéciaux de TeX
================================================================================
  Entrées : ligne d'instructions TeX
--------------------------------------------------------------------------------
  Sorties : ligne corrigée
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
correction_formateur_tex(struct_processus *s_etat_processus,
		unsigned char **ligne)
{
	logical1					mode_mathematique;

	unsigned char				*tampon;
	unsigned long				i;

	mode_mathematique = d_faux;

	for(i = 0; i < strlen((*ligne)); i++)
	{
		switch((*ligne)[i])
		{
			/*
			 * Le caractère '_' est autorisé tel quel dans une expression
			 * mathématique. Il est protégé en mode normal.
			 */

			case '$' :
			{
				mode_mathematique = (mode_mathematique == d_faux)
						? d_vrai : d_faux;

				if ((*ligne)[i + 1] == '$')
				{
					i++;
				}

				break;
			}

			/*
			 * Les '$', '{' et '}' ne sont pas convertis pour pouvoir écrire
			 * du TeX dans le texte.
			 */

			case '#' :
			case '_' :
			{
				if (mode_mathematique == d_vrai)
				{
					break;
				}
			}

			case '%' :
			case '&' :
			{
				if ((tampon = (unsigned char *) malloc((strlen((*ligne)) + 2) *
						sizeof(unsigned char))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				strncpy(tampon, (*ligne), i);
				strcpy(&(tampon[i]), "\\");
				strcat(tampon, &((*ligne)[i++]));

				free((*ligne));
				(*ligne) = tampon;

				break;
			}

			default :
			{
				break;
			}
		}
	}

	return;
}


/*
================================================================================
  Fonction 'impression_tex'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
impression_tex(struct_processus *s_etat_processus)
{
	file				*fichier_impression;

	unsigned char		*commande;
	unsigned char		*executable_candidat;
	unsigned char		*nom_fichier_aux;
	unsigned char		*nom_fichier_dvi;
	unsigned char		*nom_fichier_log;
	unsigned char		*nom_fichier_tex;
	unsigned char		*nom_fichier_ps;

	unsigned long		longueur_nom_base;

	longueur_nom_base = strlen((*s_etat_processus).nom_fichier_impression);

	if ((nom_fichier_tex = malloc((longueur_nom_base + 6) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((nom_fichier_log = malloc((longueur_nom_base + 6) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((nom_fichier_aux = malloc((longueur_nom_base + 6) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((nom_fichier_dvi = malloc((longueur_nom_base + 6) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((nom_fichier_ps = malloc((longueur_nom_base + 5) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy(nom_fichier_tex, (*s_etat_processus).nom_fichier_impression)
			[longueur_nom_base - 4] = d_code_fin_chaine;
	strcat(nom_fichier_tex, ".conv.tex");

	strcpy(nom_fichier_aux, (*s_etat_processus).nom_fichier_impression)
			[longueur_nom_base - 4] = d_code_fin_chaine;
	strcat(nom_fichier_aux, ".conv.aux");

	strcpy(nom_fichier_log, (*s_etat_processus).nom_fichier_impression)
			[longueur_nom_base - 4] = d_code_fin_chaine;
	strcat(nom_fichier_log, ".conv.log");

	strcpy(nom_fichier_dvi, (*s_etat_processus).nom_fichier_impression)
			[longueur_nom_base - 4] = d_code_fin_chaine;
	strcat(nom_fichier_dvi, ".conv.dvi");

	strcpy(nom_fichier_ps, (*s_etat_processus).nom_fichier_impression)
			[longueur_nom_base - 4] = d_code_fin_chaine;
	strcat(nom_fichier_ps, ".conv.ps");

	if ((fichier_impression = fopen((*s_etat_processus).nom_fichier_impression,
			"a")) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	if (tex_fprintf(s_etat_processus, fichier_impression,
			"\\end{document}\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	if (fclose(fichier_impression) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	if ((*s_etat_processus).rpl_home == NULL)
	{
		if (alsprintf(&commande, ds_tex_commande,
				d_exec_path, d_exec_path, d_exec_path,
				(*s_etat_processus).nom_fichier_impression,
				d_exec_path, d_exec_path,
				(*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
				(*s_etat_processus).chemin_fichiers_temporaires,
				nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
				d_exec_path) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "md5",
				rpliconv_md5) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "sha1",
				rpliconv_sha1) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		free(executable_candidat);

		if (alsprintf(&executable_candidat, "%s/bin/rplfile",
				d_exec_path) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "md5",
				rplfile_md5) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "sha1",
				rplfile_sha1) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		free(executable_candidat);
	}
	else
	{
		if (alsprintf(&commande, ds_tex_commande,
				(*s_etat_processus).rpl_home,
				(*s_etat_processus).rpl_home,
				(*s_etat_processus).rpl_home,
				(*s_etat_processus).nom_fichier_impression,
				(*s_etat_processus).rpl_home,
				(*s_etat_processus).rpl_home,
				(*s_etat_processus).nom_fichier_impression, nom_fichier_tex,
				(*s_etat_processus).chemin_fichiers_temporaires,
				nom_fichier_tex, nom_fichier_dvi, nom_fichier_ps) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (alsprintf(&executable_candidat, "%s/bin/rpliconv",
				(*s_etat_processus).rpl_home) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "md5",
				rpliconv_md5) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "sha1",
				rpliconv_sha1) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		free(executable_candidat);

		if (alsprintf(&executable_candidat, "%s/bin/rplfile",
				(*s_etat_processus).rpl_home) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "md5",
				rplfile_md5) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		if (controle(s_etat_processus, executable_candidat, "sha1",
				rplfile_sha1) != d_vrai)
		{
			(*s_etat_processus).erreur_systeme = d_es_somme_controle;
			return;
		}

		free(executable_candidat);
	}

	if (system(commande) != 0)
	{
		(*s_etat_processus).erreur_execution = d_ex_erreur_impression;
		free(commande);
	}
	else
	{
		free(commande);

		if (alsprintf(&commande, ds_tex_postscript, nom_fichier_ps) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (system(commande) != 0)
		{
			(*s_etat_processus).erreur_execution = d_ex_erreur_impression;
		}

		free(commande);

		if (destruction_fichier(nom_fichier_ps) == d_erreur)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	if (destruction_fichier((*s_etat_processus).nom_fichier_impression)
			== d_erreur)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	free((*s_etat_processus).nom_fichier_impression);
	(*s_etat_processus).nom_fichier_impression = NULL;

	if (destruction_fichier(nom_fichier_tex) == d_erreur)
	{
		free(nom_fichier_aux);
		free(nom_fichier_log);
		free(nom_fichier_dvi);
		free(nom_fichier_tex);
		free(nom_fichier_ps);

		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	if (destruction_fichier(nom_fichier_aux) == d_erreur)
	{
		free(nom_fichier_aux);
		free(nom_fichier_log);
		free(nom_fichier_dvi);
		free(nom_fichier_tex);
		free(nom_fichier_ps);

		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	if (destruction_fichier(nom_fichier_dvi) == d_erreur)
	{
		free(nom_fichier_aux);
		free(nom_fichier_log);
		free(nom_fichier_dvi);
		free(nom_fichier_tex);
		free(nom_fichier_ps);

		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	if (destruction_fichier(nom_fichier_log) == d_erreur)
	{
		free(nom_fichier_aux);
		free(nom_fichier_log);
		free(nom_fichier_dvi);
		free(nom_fichier_tex);
		free(nom_fichier_ps);

		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	free(nom_fichier_aux);
	free(nom_fichier_log);
	free(nom_fichier_dvi);
	free(nom_fichier_tex);
	free(nom_fichier_ps);

	return;
}


/*
================================================================================
  Conversion des éléments TeX par ajout si nécessaire de parenthèses
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
conversion_element_tex(unsigned char **element, unsigned char *fonction)
{
	unsigned char			*chaine;
	unsigned char			*element_courant;
	unsigned char			*extrait;

	unsigned long			debut_fonction;
	unsigned long			i;
	unsigned long			niveau;
	unsigned long			nombre_passages_par_zero;

	element_courant = (*element);
	niveau = 0;
	nombre_passages_par_zero = 0;
	i = 1;
	debut_fonction = 1;

	while((*element_courant) != d_code_fin_chaine)
	{
		if ((*element_courant) == '{')
		{
			if (niveau == 0)
			{
				extrait = extraction_chaine((*element), debut_fonction, i - 1);

				if (strcmp(extrait, fonction) != 0)
				{
					nombre_passages_par_zero++;
				}

				free(extrait);
			}

			niveau++;
		}
		else if ((*element_courant) == '}')
		{
			debut_fonction = i + 1;
			niveau--;
		}

		element_courant++;
		i++;
	}

	if (nombre_passages_par_zero > 1)
	{
		chaine = (*element);

		if (((*element) = (unsigned char *) malloc((strlen(chaine) + 14) *
				sizeof(unsigned char))) == NULL)
		{
			return;
		}

		sprintf((*element), "\\left(%s\\right)", chaine);
		free(chaine);
	}

	return;
}

// vim: ts=4