/*
================================================================================
  RPL/2 (R) version 4.1.12
  Copyright (C) 1989-2012 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 "gnuplot-conv.h"


/*
================================================================================
  Fonction 'appel_gnuplot'
================================================================================
  Entrées : persistance  'E' écran, 'N' normal, 'I' impression, 'F' fichier
--------------------------------------------------------------------------------
  Sorties : néant
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

#ifdef OS2
static unsigned char *
ajout_shell(unsigned char *commande)
{
	unsigned char		*tampon;

	if ((tampon = malloc((strlen(BOURNE_SHELL) + 5 + strlen(commande) + 2) *
			sizeof(unsigned char))) == NULL)
	{
		return(NULL);
	}

	sprintf(tampon, "%s -c \"%s\"", BOURNE_SHELL, commande);
	free(commande);
	return(tampon);
}
#endif

void
appel_gnuplot(struct_processus *s_etat_processus, unsigned char persistance)
{
	file						*entree_standard;
	file						*fichier_destination;
	file						*fichier_image;
	file						*fichier_impression;
	file						*fichier_source;

	int							caractere;

	logical1					adequation_fichier;

	long						compteur_nombre_fichiers;

	real8						phi;
	real8						theta;

	struct_fichier_graphique	*l_ancienne_base_liste;
	struct_fichier_graphique	*l_base_liste;
	struct_fichier_graphique	*l_fichier_courant;

	struct_marque				*l_marque;

	unsigned char				*nom_fichier;
	unsigned char				*commande_gnuplot;

#	ifndef GNUPLOT_SUPPORT
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Attention : Support de GnuPlot non compilé !\n");
		}
		else
		{
			printf("+++Warning : GnuPlot not available !\n");
		}

		fflush(stdout);

		return;
#	endif
	
	/*
	 * Comptage du nombre des fichiers et superposition le cas échéant
	 */

	l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
	compteur_nombre_fichiers = 0;
	nom_fichier = NULL;

	while(l_fichier_courant != NULL)
	{
		compteur_nombre_fichiers++;
		l_fichier_courant = (*l_fichier_courant).suivant;
	}

	if (compteur_nombre_fichiers > ds_gnuplot_nombre_max_fichiers)
	{
		if ((*s_etat_processus).langue == 'F')
		{
			printf("+++Attention : Réduction du nombre de plans\n");
		}
		else
		{
			printf("+++Warning : Graphical depth reduction\n");
		}

		l_base_liste = (*s_etat_processus).fichiers_graphiques;
		(*s_etat_processus).fichiers_graphiques = NULL;

		while(l_base_liste != NULL)
		{
			l_fichier_courant = (*s_etat_processus).fichiers_graphiques;
			adequation_fichier = d_faux;

			while(l_fichier_courant != NULL)
			{
				if ((strcmp((*l_fichier_courant).type, (*l_base_liste).type)
						== 0) && ((*l_fichier_courant).systeme_axes ==
						(*l_base_liste).systeme_axes))
				{
					adequation_fichier = d_vrai;
					break;
				}

				l_fichier_courant = (*l_fichier_courant).suivant;
			}

			if (adequation_fichier == d_vrai)
			{
				if ((fichier_source = fopen((*l_base_liste).nom, "r"))
						== NULL)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if ((fichier_destination = fopen((*l_fichier_courant).nom,
						"a")) == NULL)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

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

				while((caractere = getc(fichier_source)) != EOF)
				{
					if (putc(caractere, fichier_destination) == EOF)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}

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

				if (((*l_fichier_courant).presence_axes == d_vrai) ||
						((*l_base_liste).presence_axes == d_vrai))
				{
					(*l_fichier_courant).presence_axes = d_vrai;
				}
				else
				{
					(*l_fichier_courant).presence_axes = d_faux;
				}

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

				free((*l_base_liste).nom);

				if ((*l_base_liste).legende != NULL)
				{
					free((*l_base_liste).legende);
				}
			}
			else
			{
				l_fichier_courant = (*s_etat_processus).fichiers_graphiques;

				if (l_fichier_courant == NULL)
				{
					if (((*s_etat_processus).fichiers_graphiques =
							(struct_fichier_graphique *) malloc(
							sizeof(struct_fichier_graphique))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					(*(*s_etat_processus).fichiers_graphiques).suivant = NULL;
					(*(*s_etat_processus).fichiers_graphiques).nom =
							(*l_base_liste).nom;
					(*(*s_etat_processus).fichiers_graphiques).legende = NULL;
					(*(*s_etat_processus).fichiers_graphiques).presence_axes =
							(*l_base_liste).presence_axes;
					strcpy((*(*s_etat_processus).fichiers_graphiques).type,
							(*l_base_liste).type);
					(*(*s_etat_processus).fichiers_graphiques).dimensions =
							(*l_base_liste).dimensions;
					(*(*s_etat_processus).fichiers_graphiques).systeme_axes =
							(*l_base_liste).systeme_axes;
				}
				else
				{
					while((*l_fichier_courant).suivant != NULL)
					{
						l_fichier_courant = (*l_fichier_courant).suivant;
					}

					if (((*l_fichier_courant).suivant =
							(struct_fichier_graphique *) malloc(
							sizeof(struct_fichier_graphique))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return;
					}

					l_fichier_courant = (*l_fichier_courant).suivant;

					(*l_fichier_courant).suivant = NULL;
					(*l_fichier_courant).nom = (*l_base_liste).nom;
					(*l_fichier_courant).legende = NULL;
					(*l_fichier_courant).presence_axes = d_faux;
					strcpy((*l_fichier_courant).type, (*l_base_liste).type);
					(*l_fichier_courant).dimensions =
							(*l_base_liste).dimensions;
					(*l_fichier_courant).systeme_axes =
							(*l_base_liste).systeme_axes;
				}
			}

			l_ancienne_base_liste = l_base_liste;
			l_base_liste = (*l_base_liste).suivant;
			free(l_ancienne_base_liste);
		}
	}

	/*
	 * Traitement du cas où l'afficheur n'est pas persistant
	 */

	if (persistance == 'N')
	{
		entree_standard = NULL;

		if ((*s_etat_processus).entree_standard == NULL)
		{
#ifdef FORCE_GNUPLOT_PATH
			if ((*s_etat_processus).rpl_home == NULL)
			{
				if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
						strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
						== NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
						ds_gnuplot_commande);
			}
			else
			{
				if ((commande_gnuplot = malloc((strlen(
						(*s_etat_processus).rpl_home) + 6 +
						strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
						== NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				sprintf(commande_gnuplot, "%s/bin/%s",
						(*s_etat_processus).rpl_home, ds_gnuplot_commande);
			}
#else
			if ((commande_gnuplot = malloc((1 +
					strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
#endif

#ifdef OS2
			if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
#endif

			if (((*s_etat_processus).entree_standard =
					popen(commande_gnuplot, "w")) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			free(commande_gnuplot);

			if (fprintf((*s_etat_processus).entree_standard,
					"%s\n", ds_gnuplot_terminal_defaut) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}

		if (strlen((*s_etat_processus).titre) > 0)
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"set title \"%s\"\n", (*s_etat_processus).titre) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
	}
	else if (persistance == 'E') /* Ecran */
	{
		entree_standard = (*s_etat_processus).entree_standard;

#if FORCE_GNUPLOT_PATH
		if ((*s_etat_processus).rpl_home == NULL)
		{
			if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
					strlen(ds_gnuplot_commande_persistante)) *
					sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
					ds_gnuplot_commande_persistante);
		}
		else
		{
			if ((commande_gnuplot = malloc((strlen(
					(*s_etat_processus).rpl_home) + 6 +
					strlen(ds_gnuplot_commande_persistante)) *
					sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
					ds_gnuplot_commande_persistante);
		}
#else
		if ((commande_gnuplot = malloc((1 +
				strlen(ds_gnuplot_commande_persistante)) *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		sprintf(commande_gnuplot, "%s", ds_gnuplot_commande_persistante);
#endif

#ifdef OS2
		if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
#endif

		if (((*s_etat_processus).entree_standard =
				popen(commande_gnuplot, "w")) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		free(commande_gnuplot);

		if (fprintf((*s_etat_processus).entree_standard,
				"%s\n", ds_gnuplot_terminal_defaut) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (strlen((*s_etat_processus).titre) > 0)
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"set title \"%s\"\n", (*s_etat_processus).titre) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
	}
	else if (persistance == 'I') /* Imprimante */
	{
		entree_standard = (*s_etat_processus).entree_standard;

#ifdef FORCE_GNUPLOT_PATH
		if ((*s_etat_processus).rpl_home == NULL)
		{
			if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
					strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
					ds_gnuplot_commande);
		}
		else
		{
			if ((commande_gnuplot = malloc((strlen((*s_etat_processus).rpl_home)
					+ 6 + strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
					ds_gnuplot_commande);
		}
#else
		if ((commande_gnuplot = malloc((1 +
				strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
#endif

#ifdef OS2
		if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
#endif

		if (((*s_etat_processus).entree_standard =
				popen(commande_gnuplot, "w")) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		free(commande_gnuplot);

		if (fprintf((*s_etat_processus).entree_standard,
				"%s\n", ds_gnuplot_terminal_defaut) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

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

		if (fprintf((*s_etat_processus).entree_standard,
				"set terminal latex\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard, "set output \"%s\"\n",
				nom_fichier) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else /* persistance == 'F' comme fichier */
	{
		entree_standard = (*s_etat_processus).entree_standard;

#ifdef FORCE_GNUPLOT_PATH
		if ((*s_etat_processus).rpl_home == NULL)
		{
			if ((commande_gnuplot = malloc((strlen(d_exec_path) + 6 +
					strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf(commande_gnuplot, "%s/bin/%s", d_exec_path,
					ds_gnuplot_commande);
		}
		else
		{
			if ((commande_gnuplot = malloc((strlen((*s_etat_processus).rpl_home)
					+ 6 + strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf(commande_gnuplot, "%s/bin/%s", (*s_etat_processus).rpl_home,
					ds_gnuplot_commande);
		}
#else
		if ((commande_gnuplot = malloc((1 +
				strlen(ds_gnuplot_commande)) * sizeof(unsigned char)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		sprintf(commande_gnuplot, "%s", ds_gnuplot_commande);
#endif

#ifdef OS2
		if ((commande_gnuplot = ajout_shell(commande_gnuplot)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
#endif

		if (((*s_etat_processus).entree_standard =
				popen(commande_gnuplot, "w")) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		free(commande_gnuplot);

		if (fprintf((*s_etat_processus).entree_standard, "set terminal %s\n",
				(*s_etat_processus).type_fichier_gnuplot) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard, "set output \"%s\"\n",
				(*s_etat_processus).nom_fichier_gnuplot) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		free((*s_etat_processus).nom_fichier_gnuplot);
		free((*s_etat_processus).type_fichier_gnuplot);

		(*s_etat_processus).nom_fichier_gnuplot = NULL;
		(*s_etat_processus).type_fichier_gnuplot = NULL;

		if (strlen((*s_etat_processus).titre) > 0)
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"set title \"%s\"\n", (*s_etat_processus).titre) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
	}

	/*
	 * Affichace des marques
	 */

	l_marque = (*s_etat_processus).s_marques;

	while(l_marque != NULL)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set label \"%s\" at %s point front offset 0.2,0.2\n",
				(*l_marque).label, (*l_marque).position) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		l_marque = (*l_marque).suivant;
	}

	/*
	 * Affichage, le cas échéant, des graduations
	 */

	if ((*s_etat_processus).x_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset xtics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).x_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set xtics autofreq\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set xtics %f\n",
				(*s_etat_processus).x_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).mx_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset mxtics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).mx_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set mxtics default\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set mxtics %lld\n",
				(*s_etat_processus).mx_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).y_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset ytics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).y_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set ytics autofreq\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set ytics %f\n",
				(*s_etat_processus).y_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).my_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset mytics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).my_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set mytics default\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set mytics %lld\n",
				(*s_etat_processus).my_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).z_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset ztics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).z_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set ztics autofreq\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set ztics %f\n",
				(*s_etat_processus).z_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).mz_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset mztics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).mz_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set mztics default\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set mztics %lld\n",
				(*s_etat_processus).mz_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).x2_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset x2tics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).x2_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set x2tics autofreq\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set x2tics %f\n",
				(*s_etat_processus).x2_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).mx2_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset mx2tics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).mx2_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set mx2tics default\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set mx2tics %lld\n",
				(*s_etat_processus).mx2_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).y2_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset y2tics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).y2_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set y2tics autofreq\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set y2tics %f\n",
				(*s_etat_processus).y2_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).my2_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset my2tics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).my2_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set my2tics default\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set my2tics %lld\n",
				(*s_etat_processus).my2_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).z2_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset z2tics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).z2_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set z2tics autofreq\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set z2tics %f\n",
				(*s_etat_processus).z2_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).mz2_tics < 0)
	{
		if (fprintf((*s_etat_processus).entree_standard, "unset mz2tics\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else if ((*s_etat_processus).mz2_tics == 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set mz2tics default\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard, "set mz2tics %lld\n",
				(*s_etat_processus).mz2_tics) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	l_fichier_courant = (*s_etat_processus).fichiers_graphiques;

	while(l_fichier_courant != NULL)
	{
		if ((*l_fichier_courant).presence_axes == d_vrai)
		{
			if ((*s_etat_processus).x_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid xtics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).y_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid ytics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).z_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid ztics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).x2_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid x2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).y2_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid y2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).z2_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid z2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).mx_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid mxtics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).my_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid mytics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).mz_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid mztics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).mx2_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid mx2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).my2_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid my2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((*s_etat_processus).mz2_lines == d_vrai)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid mz2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if ((strcmp((*l_fichier_courant).type, "FONCTION") == 0) ||
					(strcmp((*l_fichier_courant).type, "PARAMETRIQUE") == 0) ||
					(strcmp((*l_fichier_courant).type, "POINTS") == 0) ||
					(strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0) ||
					(strcmp((*l_fichier_courant).type, "TABLE TRACANTE") == 0)
				   	|| (strcmp((*l_fichier_courant).type, "COURBES DE NIVEAU")
					== 0) ||
					(strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0))
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set grid\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
			else if (strcmp((*l_fichier_courant).type, "POLAIRE") == 0)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set xtics axis nomirror\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"set ytics axis nomirror\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"set grid polar\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
				
				if (fprintf((*s_etat_processus).entree_standard,
						"set size square\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"unset x2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"unset y2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"unset z2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"unset mx2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"unset my2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				if (fprintf((*s_etat_processus).entree_standard,
						"unset mz2tics\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}

		l_fichier_courant = (*l_fichier_courant).suivant;
	}

	/*
	 * Gestion des noms des axes
	 */

	if (fprintf((*s_etat_processus).entree_standard,
			"set xlabel \"%s\"\n", (*s_etat_processus).label_x) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (fprintf((*s_etat_processus).entree_standard,
			"set ylabel \"%s\"\n", (*s_etat_processus).label_y) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (fprintf((*s_etat_processus).entree_standard,
			"set zlabel \"%s\"\n", (*s_etat_processus).label_z) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}


	/*
	 * Gestion des échelles automatiques
	 */

	if ((*s_etat_processus).echelle_automatique_x == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set autoscale x\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset autoscale x\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard, "set xrange [%f:%f]\n",
				(*s_etat_processus).x_min, (*s_etat_processus).x_max) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_automatique_x2 == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set autoscale x2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset autoscale x2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard,
				"set x2range [%f:%f]\n",
				(*s_etat_processus).x2_min, (*s_etat_processus).x2_max) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_automatique_y == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set autoscale y\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset autoscale y\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard, "set yrange [%f:%f]\n",
				(*s_etat_processus).y_min, (*s_etat_processus).y_max) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_automatique_y2 == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set autoscale y2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset autoscale y2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard,
				"set y2range [%f:%f]\n",
				(*s_etat_processus).y2_min, (*s_etat_processus).y2_max) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_automatique_z == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set autoscale z\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset autoscale z\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard, "set zrange [%f:%f]\n",
				(*s_etat_processus).z_min, (*s_etat_processus).z_max) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_automatique_z2 == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set autoscale z2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset autoscale z2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fprintf((*s_etat_processus).entree_standard,
				"set z2range [%f:%f]\n",
				(*s_etat_processus).z_min, (*s_etat_processus).z_max) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	/*
	 * Position du point de vue
	 */

	theta = (*s_etat_processus).point_de_vue_theta;
	phi = (*s_etat_processus).point_de_vue_phi;

	conversion_radians_vers_degres(&theta);
	conversion_radians_vers_degres(&phi);

	if (theta < 0)
	{
		theta = 0;
	}
	else if (theta > 360)
	{
		theta = 360;
	}

	if (phi < 0)
	{
		phi = 0;
	}
	else if (phi > 180)
	{
		phi = 180;
	}

	if (fprintf((*s_etat_processus).entree_standard,
			"set view %f,%f,1,%f\n", phi, theta,
			(*s_etat_processus).echelle_3D) < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	/*
	 * Gestion des échelles logarithmiques
	 */

	if ((*s_etat_processus).echelle_log_x == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set logscale x\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset logscale x\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_log_y == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set logscale y\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset logscale y\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_log_z == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set logscale z\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset logscale z\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_log_x2 == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set logscale x2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset logscale x2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_log_y2 == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set logscale y2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset logscale y2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).echelle_log_z2 == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set logscale z2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset logscale z2\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	/*
	 * Gestion de la souris
	 */

	if ((*s_etat_processus).souris_active == d_vrai)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set mouse\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"unset mouse\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	/*
	 * Affichage des tracés
	 */

	l_fichier_courant = (*s_etat_processus).fichiers_graphiques;

	if (strlen((*s_etat_processus).legende) > 0)
	{
		if (fprintf((*s_etat_processus).entree_standard,
				"set key outside autotitle title \"%s\"\n",
				(*s_etat_processus).legende) < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}
	else
	{
		l_fichier_courant = (*s_etat_processus).fichiers_graphiques;

		while(l_fichier_courant != NULL)
		{
			if ((*l_fichier_courant).legende != NULL)
			{
				break;
			}

			l_fichier_courant = (*l_fichier_courant).suivant;
		}

		if (l_fichier_courant == NULL)
		{
			if (fprintf((*s_etat_processus).entree_standard, "unset key\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"set key outside autotitle\n") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
	}

	l_fichier_courant = (*s_etat_processus).fichiers_graphiques;

	if (l_fichier_courant != NULL)
	{
		if ((*l_fichier_courant).dimensions == 2)
		{
			if (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set boxwidth %d\n",
						ds_gnuplot_option_largeur_histogramme) < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (fprintf((*s_etat_processus).entree_standard, "%s ",
					ds_gnuplot_commande_trace_2D) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else
		{
			if (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0)
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"set hidden3d\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
			else
			{
				if (fprintf((*s_etat_processus).entree_standard,
						"unset hidden3d\n") < 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (fprintf((*s_etat_processus).entree_standard, "%s ",
					ds_gnuplot_commande_trace_3D) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
	}

	while(l_fichier_courant != NULL)
	{
		if ((strcmp((*l_fichier_courant).type, "FONCTION") == 0) ||
				(strcmp((*l_fichier_courant).type, "PARAMETRIQUE") == 0) ||
				(strcmp((*l_fichier_courant).type, "POLAIRE") == 0) ||
				(strcmp((*l_fichier_courant).type, "COURBES DE NIVEAU") == 0))
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"\"%s\" axes %s %s",
					(*l_fichier_courant).nom,
					((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
					ds_gnuplot_option_2D) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else if (strcmp((*l_fichier_courant).type, "POINTS") == 0)
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"\"%s\" axes %s %s",
					(*l_fichier_courant).nom,
					((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
					ds_gnuplot_option_nuages) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else if (strcmp((*l_fichier_courant).type, "HISTOGRAMME") == 0)
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"\"%s\" axes %s %s",
					(*l_fichier_courant).nom,
					((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
					ds_gnuplot_option_histogramme)
					< 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else if (strcmp((*l_fichier_courant).type, "TABLE TRACANTE") == 0)
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"\"%s\" axes %s %s",
					(*l_fichier_courant).nom,
					((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
					ds_gnuplot_option_table_tracante)
					< 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else if (strcmp((*l_fichier_courant).type, "DESSIN") == 0)
		{
			if (fprintf((*s_etat_processus).entree_standard,
					"\"%s\" axes %s %s",
					(*l_fichier_courant).nom,
					((*l_fichier_courant).systeme_axes == 0) ? "x1y1" : "x2y2",
					ds_gnuplot_option_table_tracante)
					< 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else if (strcmp((*l_fichier_courant).type, "GRILLE 3D") == 0)
		{
			if (fprintf((*s_etat_processus).entree_standard, "\"%s\" %s",
					(*l_fichier_courant).nom, ds_gnuplot_option_3D) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}

		if ((*l_fichier_courant).legende == NULL)
		{
			if (fprintf((*s_etat_processus).entree_standard, " notitle") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
		else
		{
			if (fprintf((*s_etat_processus).entree_standard, " title \"%s\"",
					(*l_fichier_courant).legende) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}

		if (fflush((*s_etat_processus).entree_standard) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		l_fichier_courant = (*l_fichier_courant).suivant;

		if (l_fichier_courant != NULL)
		{
			if (fprintf((*s_etat_processus).entree_standard, ", ") < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}
	}

	if (fprintf((*s_etat_processus).entree_standard, "\n") < 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (fflush((*s_etat_processus).entree_standard) != 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	if (persistance == 'I')
	{
		if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
		
		if (fflush((*s_etat_processus).entree_standard) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (pclose((*s_etat_processus).entree_standard) == -1)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		(*s_etat_processus).entree_standard = entree_standard;

		/*
		 * 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;
			}
		}

		if (fflush(NULL) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		if ((fichier_image = fopen(nom_fichier, "r")) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

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

		while((caractere = getc(fichier_image)) != EOF)
		{
			if (putc(caractere, fichier_impression) == EOF)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

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

		if (strlen((*s_etat_processus).titre) > 0)
		{
			if (tex_fprintf(s_etat_processus, fichier_impression,
					"\\caption{%s}\n", (*s_etat_processus).titre) < 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
				return;
			}
		}

		if (tex_fprintf(s_etat_processus, fichier_impression,
					"\\end{figure}\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 (destruction_fichier(nom_fichier) == d_erreur)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		free(nom_fichier);
	}
	else if (persistance == 'E')
	{
		if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
		
		if (fflush((*s_etat_processus).entree_standard) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (pclose((*s_etat_processus).entree_standard) == -1)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		(*s_etat_processus).entree_standard = entree_standard;
	}
	else if (entree_standard != NULL)
	{
		if (fprintf((*s_etat_processus).entree_standard, "quit\n") < 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (fflush((*s_etat_processus).entree_standard) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		if (pclose((*s_etat_processus).entree_standard) == -1)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		(*s_etat_processus).entree_standard = entree_standard;
	}

	return;
}

// vim: ts=4