/*
================================================================================
  RPL/2 (R) version 4.1.32
  Copyright (C) 1989-2020 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"


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

void
instruction_ppar(struct_processus *s_etat_processus)
{
	struct_liste_chainee			*l_ancienne_base;
	struct_liste_chainee			*l_nouvelle_base;

	struct_objet					*s_objet_resultat;

	/*
	 * { { Xmin Xmax } { Ymin Ymax } { Zmin Zmax }
	 * 		INDEP DEPND RES { EYEPT } }
	 * { "automatic" { Ymin Ymax } "automatic" INDEP DEPND RES { EYEPT } }
	 */

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  PPAR ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(paramètres graphiques)\n\n");
		}
		else
		{
			printf("(graphical parameters)\n\n");
		}

		printf("->  1: %s\n", d_LST);

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}
	}

	if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*s_objet_resultat).objet = NULL;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Paramètres des courbes de niveau

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus,
			(*s_etat_processus).parametres_courbes_de_niveau, 'O')) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Point de vue

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, LST))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;

	if (((*(*l_nouvelle_base).donnee).objet =
			allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet)).donnee
			= allocation(s_etat_processus, REL)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((real8 *) (*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			.objet)).donnee).objet)) = (*s_etat_processus).point_de_vue_theta;

	if (test_cfsf(s_etat_processus, 60) == d_faux)
	{
		conversion_radians_vers_degres((real8 *) (*(*((struct_liste_chainee *)
				(*(*l_nouvelle_base).donnee).objet)).donnee).objet);
	}

	if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
			.suivant = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
			.suivant).donnee = allocation(s_etat_processus, REL)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((real8 *) (*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			.objet)).suivant).donnee).objet)) =
			(*s_etat_processus).point_de_vue_phi;

	if (test_cfsf(s_etat_processus, 60) == d_faux)
	{
		conversion_radians_vers_degres((real8 *) (*(*(*((struct_liste_chainee *)
				(*(*l_nouvelle_base).donnee).objet)).suivant).donnee).objet);
	}

	if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
			.suivant).suivant = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
			.suivant).suivant).donnee = allocation(s_etat_processus, REL))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((real8 *) (*(*(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			.objet)).suivant).suivant).donnee).objet)) =
			(*s_etat_processus).echelle_3D;

	(*((*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
			.suivant)).suivant)).suivant = NULL;

	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Type en cours

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, CHN))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;

	if (strcmp((*s_etat_processus).type_trace_eq, "FONCTION") == 0)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(9 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"FUNCTION");
	}
	else if (strcmp((*s_etat_processus).type_trace_eq, "PARAMETRIQUE") == 0)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(11 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"PARAMETRIC");
	}
	else if (strcmp((*s_etat_processus).type_trace_eq, "POLAIRE") == 0)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(6 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"POLAR");
	}
	else if (strcmp((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU")
			== 0)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(6 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"SLICE");
	}
	else if (strcmp((*s_etat_processus).type_trace_eq, "GRILLE 3D") == 0)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"WIREFRAME");
	}
	else
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet, "");
	}

	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Résolution

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, REL))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*((real8 *) (*(*l_nouvelle_base).donnee).objet)) =
			(*s_etat_processus).resolution;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// DEPND

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus,
			(*s_etat_processus).depend, 'O')) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// INDEP
	
	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = copie_objet(s_etat_processus,
			(*s_etat_processus).indep, 'O')) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Coordonnées Z2

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((*s_etat_processus).echelle_automatique_z2 == d_vrai)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*l_nouvelle_base).donnee).type = CHN;
		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"AUTOMATIC");
	}
	else
	{
		(*(*l_nouvelle_base).donnee).type = LST;

		if (((*(*l_nouvelle_base).donnee).objet =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.donnee = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			  	.objet)).donnee)).objet)) = (*s_etat_processus).z2_min;

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant = allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).suivant = NULL;

		if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).donnee = allocation(s_etat_processus, REL))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
				.donnee).objet)).suivant).donnee)).objet)) =
				(*s_etat_processus).z2_max;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Coordonnées Y2

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((*s_etat_processus).echelle_automatique_y2 == d_vrai)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*l_nouvelle_base).donnee).type = CHN;
		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"AUTOMATIC");
	}
	else
	{
		(*(*l_nouvelle_base).donnee).type = LST;

		if (((*(*l_nouvelle_base).donnee).objet =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.donnee = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			  	.objet)).donnee)).objet)) = (*s_etat_processus).y2_min;

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant = allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).suivant = NULL;

		if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).donnee = allocation(s_etat_processus, REL))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
				.donnee).objet)).suivant).donnee)).objet)) =
				(*s_etat_processus).y2_max;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Coordonnées X2

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((*s_etat_processus).echelle_automatique_x2 == d_vrai)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*l_nouvelle_base).donnee).type = CHN;
		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"AUTOMATIC");
	}
	else
	{
		(*(*l_nouvelle_base).donnee).type = LST;

		if (((*(*l_nouvelle_base).donnee).objet =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.donnee = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			  	.objet)).donnee)).objet)) = (*s_etat_processus).x2_min;

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant = allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).suivant = NULL;

		if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).donnee = allocation(s_etat_processus, REL))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
				.donnee).objet)).suivant).donnee)).objet)) =
				(*s_etat_processus).x2_max;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Coordonnées Z

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((*s_etat_processus).echelle_automatique_z == d_vrai)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*l_nouvelle_base).donnee).type = CHN;
		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"AUTOMATIC");
	}
	else
	{
		(*(*l_nouvelle_base).donnee).type = LST;

		if (((*(*l_nouvelle_base).donnee).objet =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.donnee = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			  	.objet)).donnee)).objet)) = (*s_etat_processus).z_min;

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant = allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).suivant = NULL;

		if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).donnee = allocation(s_etat_processus, REL))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
				.donnee).objet)).suivant).donnee)).objet)) =
				(*s_etat_processus).z_max;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Coordonnées Y

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((*s_etat_processus).echelle_automatique_y == d_vrai)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*l_nouvelle_base).donnee).type = CHN;
		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"AUTOMATIC");
	}
	else
	{
		(*(*l_nouvelle_base).donnee).type = LST;

		if (((*(*l_nouvelle_base).donnee).objet =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.donnee = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			  	.objet)).donnee)).objet)) = (*s_etat_processus).y_min;

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant = allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).suivant = NULL;

		if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).donnee = allocation(s_etat_processus, REL))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
				.donnee).objet)).suivant).donnee)).objet)) =
				(*s_etat_processus).y_max;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;
	l_ancienne_base = (*s_objet_resultat).objet;

	// Coordonnées X

	if ((l_nouvelle_base = allocation_maillon(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*l_nouvelle_base).donnee = allocation(s_etat_processus, NON))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if ((*s_etat_processus).echelle_automatique_x == d_vrai)
	{
		if (((*(*l_nouvelle_base).donnee).objet = malloc(10 *
				sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*l_nouvelle_base).donnee).type = CHN;
		strcpy((unsigned char *) (*(*l_nouvelle_base).donnee).objet,
				"AUTOMATIC");
	}
	else
	{
		(*(*l_nouvelle_base).donnee).type = LST;

		if (((*(*l_nouvelle_base).donnee).objet =
				allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.donnee = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee)
			  	.objet)).donnee)).objet)) = (*s_etat_processus).x_min;

		if (((*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant = allocation_maillon(s_etat_processus)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).suivant = NULL;

		if (((*(*((struct_liste_chainee *) (*(*l_nouvelle_base).donnee).objet))
				.suivant).donnee = allocation(s_etat_processus, REL))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*((*(*((struct_liste_chainee *) (*(*l_nouvelle_base)
				.donnee).objet)).suivant).donnee)).objet)) =
				(*s_etat_processus).x_max;
	}

	(*l_nouvelle_base).suivant = l_ancienne_base;
	(*s_objet_resultat).objet = l_nouvelle_base;

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

	return;
}


/*
================================================================================
  Fonction 'plotter' (passe en mode d'affichage relié)
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_plotter(struct_processus *s_etat_processus)
{
	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  PLOTTER ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(nuage de points reliés entre eux)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(plotter mode)\n\n");
			printf("  No argument\n");
		}

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}
	
	strcpy((*s_etat_processus).type_trace_sigma, "TABLE TRACANTE");

	return;
}


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

void
instruction_paper(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument;

	unsigned char				*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  PAPER ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(format de papier)\n\n");
		}
		else
		{
			printf("(paper format)\n\n");
		}

		printf("    1: %s\n\n", d_CHN);

		if ((*s_etat_processus).langue == 'F')
		{
			printf("  Formats :\n\n");
		}
		else
		{
			printf("  Format:\n\n");
		}

		printf("    A4, A5, B5, EXECUTIVE, LETTER, LEGAL\n");

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}
	
	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
		{
			return;
		}
	}

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

	if ((*s_objet_argument).type == CHN)
	{
		if ((tampon = conversion_majuscule(s_etat_processus, (unsigned char *)
				(*s_objet_argument).objet)) == NULL)

		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (strcmp(tampon, "A4") == 0)
		{
			strcpy((*s_etat_processus).format_papier, "a4paper");
		}
		else if (strcmp(tampon, "A5") == 0)
		{
			strcpy((*s_etat_processus).format_papier, "a5paper");
		}
		else if (strcmp(tampon, "B5") == 0)
		{
			strcpy((*s_etat_processus).format_papier, "b5paper");
		}
		else if (strcmp(tampon, "LETTER") == 0)
		{
			strcpy((*s_etat_processus).format_papier, "letterpaper");
		}
		else if (strcmp(tampon, "LEGAL") == 0)
		{
			strcpy((*s_etat_processus).format_papier, "legalpaper");
		}
		else if (strcmp(tampon, "EXECUTIVE") == 0)
		{
			strcpy((*s_etat_processus).format_papier, "executivepaper");
		}
		else
		{
			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		}

		free(tampon);
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument);

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

	liberation(s_etat_processus, s_objet_argument);

	return;
}

// vim: ts=4