/*
================================================================================
  RPL/2 (R) version 4.1.0.prerelease.3
  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"


/*
================================================================================
  Fonction 'legv'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_legv(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_resultat_1;
	struct_objet				*s_objet_resultat_2;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  LEGV ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(valeurs et vecteurs propres gauches)\n\n");
		}
		else
		{
			printf("(eigenvalues and left eigenvectors)\n\n");
		}

		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  2: %s\n", d_MCX);
		printf("    1: %s\n", d_VCX);

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

/*
--------------------------------------------------------------------------------
  L'argument est une matrice carrée
--------------------------------------------------------------------------------
*/

	if (((*s_objet_argument).type == MIN) ||
			((*s_objet_argument).type == MRL) ||
			((*s_objet_argument).type == MCX))
	{
		if ((*((struct_matrice *) (*s_objet_argument).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument).objet))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument);

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

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

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

		valeurs_propres(s_etat_processus,
				(struct_matrice *) (*s_objet_argument).objet,
				(struct_vecteur *) (*s_objet_resultat_1).objet,
				(struct_matrice *) (*s_objet_resultat_2).objet, NULL);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument);
			liberation(s_etat_processus, s_objet_resultat_1);
			liberation(s_etat_processus, s_objet_resultat_2);
			return;
		}
	}

/*
--------------------------------------------------------------------------------
  Type incompatible
--------------------------------------------------------------------------------
*/

	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);

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

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

	return;
}


/*
================================================================================
  Fonction 'lsq'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_lsq(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet_argument_1;
	struct_objet				*s_objet_argument_2;
	struct_objet				*s_objet_resultat;

	struct_matrice				s_matrice_tampon_b;
	struct_matrice				s_matrice_tampon_x;

	unsigned long				i;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  LSQ ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(moindres carrés)\n\n");
		}
		else
		{
			printf("(least squares)\n\n");
		}

		printf("    2: %s, %s\n", d_VIN, d_VRL);
		printf("    1: %s, %s\n", d_MIN, d_MRL);
		printf("->  1: %s\n\n", d_VRL);

		printf("    2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  1: %s\n\n", d_VCX);

		printf("    2: %s, %s\n", d_MIN, d_MRL);
		printf("    1: %s, %s\n", d_MIN, d_MRL);
		printf("->  1: %s\n\n", d_MRL);

		printf("    2: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  1: %s\n", d_MCX);

		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, 2) == d_erreur)
		{
			return;
		}
	}

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

/*
--------------------------------------------------------------------------------
  Vecteur et matrice
--------------------------------------------------------------------------------
*/

	/*
	 * Résultat réel
	 */

	if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL)) &&
			(((*s_objet_argument_2).type == VIN) ||
			((*s_objet_argument_2).type == VRL)))
	{
		if ((*((struct_vecteur *) (*s_objet_argument_2).objet)).taille !=
				(*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_lignes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if ((*s_objet_argument_2).type == VIN)
		{
			s_matrice_tampon_b.type = 'I';
			s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).taille;
			s_matrice_tampon_b.nombre_colonnes = 1;

			if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
					.nombre_lignes * sizeof(integer8 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				if ((((integer8 **) s_matrice_tampon_b.tableau)[i] =
						malloc(sizeof(integer8))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				((integer8 **) s_matrice_tampon_b.tableau)[i][0] =
						((integer8 *) (*((struct_vecteur *)
						(*s_objet_argument_2).objet)).tableau)[i];
			}
		}
		else
		{
			s_matrice_tampon_b.type = 'R';
			s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).taille;
			s_matrice_tampon_b.nombre_colonnes = 1;

			if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
					.nombre_lignes * sizeof(real8 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				if ((((real8 **) s_matrice_tampon_b.tableau)[i] =
						malloc(sizeof(real8))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				((real8 **) s_matrice_tampon_b.tableau)[i][0] =
						((real8 *) (*((struct_vecteur *)
						(*s_objet_argument_2).objet)).tableau)[i];
			}
		}

		moindres_carres(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet,
				&s_matrice_tampon_b, &s_matrice_tampon_x);

		if ((*s_objet_argument_2).type == VIN)
		{
			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				free(((integer8 **) s_matrice_tampon_b.tableau)[i]);
			}
		}
		else
		{
			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				free(((real8 **) s_matrice_tampon_b.tableau)[i]);
			}
		}

		free(s_matrice_tampon_b.tableau);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			return;
		}

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				s_matrice_tampon_x.nombre_lignes;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_vecteur *) (*s_objet_resultat).objet)).taille
				* sizeof(real8))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet)).taille;
				i++)
		{
			((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
					.tableau)[i] = ((real8 **) s_matrice_tampon_x.tableau)
					[i][0];
			free(((real8 **) s_matrice_tampon_x.tableau)[i]);
		}

		free(s_matrice_tampon_x.tableau);
	}

	/*
	 * Résultat complexe
	 */

	else if ((((*s_objet_argument_1).type == MCX) &&
			(((*s_objet_argument_2).type == VIN) ||
			((*s_objet_argument_2).type == VRL) ||
			((*s_objet_argument_2).type == VCX))) ||
			(((*s_objet_argument_2).type == VCX) &&
			(((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL))))
	{
		if ((*((struct_vecteur *) (*s_objet_argument_2).objet)).taille !=
				(*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_lignes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if ((*s_objet_argument_2).type == VIN)
		{
			s_matrice_tampon_b.type = 'I';
			s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).taille;
			s_matrice_tampon_b.nombre_colonnes = 1;

			if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
					.nombre_lignes * sizeof(integer8 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				if ((((integer8 **) s_matrice_tampon_b.tableau)[i] =
						malloc(sizeof(integer8))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				((integer8 **) s_matrice_tampon_b.tableau)[i][0] =
						((integer8 *) (*((struct_vecteur *)
						(*s_objet_argument_2).objet)).tableau)[i];
			}
		}
		else if ((*s_objet_argument_2).type == VRL)
		{
			s_matrice_tampon_b.type = 'R';
			s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).taille;
			s_matrice_tampon_b.nombre_colonnes = 1;

			if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
					.nombre_lignes * sizeof(real8 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				if ((((real8 **) s_matrice_tampon_b.tableau)[i] =
						malloc(sizeof(real8))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				((real8 **) s_matrice_tampon_b.tableau)[i][0] =
						((real8 *) (*((struct_vecteur *)
						(*s_objet_argument_2).objet)).tableau)[i];
			}
		}
		else
		{
			s_matrice_tampon_b.type = 'C';
			s_matrice_tampon_b.nombre_lignes = (*((struct_vecteur *)
					(*s_objet_argument_2).objet)).taille;
			s_matrice_tampon_b.nombre_colonnes = 1;

			if ((s_matrice_tampon_b.tableau = malloc(s_matrice_tampon_b
					.nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				if ((((struct_complexe16 **) s_matrice_tampon_b.tableau)[i] =
						malloc(sizeof(struct_complexe16))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				((struct_complexe16 **) s_matrice_tampon_b.tableau)[i][0]
				   		.partie_reelle = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[i].partie_reelle;
				((struct_complexe16 **) s_matrice_tampon_b.tableau)[i][0]
				   		.partie_imaginaire = ((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[i].partie_imaginaire;
			}
		}

		moindres_carres(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet,
				&s_matrice_tampon_b, &s_matrice_tampon_x);

		if ((*s_objet_argument_2).type == VIN)
		{
			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				free(((integer8 **) s_matrice_tampon_b.tableau)[i]);
			}
		}
		else if ((*s_objet_argument_2).type == VRL)
		{
			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				free(((real8 **) s_matrice_tampon_b.tableau)[i]);
			}
		}
		else
		{
			for(i = 0; i < s_matrice_tampon_b.nombre_lignes; i++)
			{
				free(((struct_complexe16 **) s_matrice_tampon_b.tableau)[i]);
			}
		}

		free(s_matrice_tampon_b.tableau);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			return;
		}

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				s_matrice_tampon_x.nombre_lignes;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_vecteur *) (*s_objet_resultat).objet)).taille
				* sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		for(i = 0; i < (*((struct_vecteur *) (*s_objet_resultat).objet)).taille;
				i++)
		{
			((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
					.objet)).tableau)[i].partie_reelle = ((struct_complexe16 **)
					s_matrice_tampon_x.tableau)[i][0].partie_reelle;
			((struct_complexe16 *) (*((struct_vecteur *) (*s_objet_resultat)
					.objet)).tableau)[i].partie_imaginaire =
					((struct_complexe16 **) s_matrice_tampon_x.tableau)[i][0]
					.partie_imaginaire;
			free(((real8 **) s_matrice_tampon_x.tableau)[i]);
		}

		free(s_matrice_tampon_x.tableau);
	}

/*
--------------------------------------------------------------------------------
  Matrices
--------------------------------------------------------------------------------
*/

	/*
	 * Résultat réel
	 */

	else if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL)) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL)))
	{
		if ((*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_lignes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		moindres_carres(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet,
				(struct_matrice *) (*s_objet_argument_2).objet,
				&s_matrice_tampon_x);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			return;
		}

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

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				s_matrice_tampon_x.nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				s_matrice_tampon_x.nombre_colonnes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				s_matrice_tampon_x.tableau;
	}

	/*
	 * Résultat complexe
	 */

	else if ((((*s_objet_argument_1).type == MCX) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL) ||
			((*s_objet_argument_2).type == MCX))) ||
			(((*s_objet_argument_2).type == MCX) &&
			(((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL))))
	{
		if ((*((struct_matrice *) (*s_objet_argument_2).objet)).nombre_lignes !=
				(*((struct_matrice *) (*s_objet_argument_1).objet))
				.nombre_lignes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		moindres_carres(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet,
				(struct_matrice *) (*s_objet_argument_2).objet,
				&s_matrice_tampon_x);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}

		if (((*s_etat_processus).exception != d_ep) ||
				((*s_etat_processus).erreur_execution != d_ex))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			return;
		}

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

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				s_matrice_tampon_x.nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				s_matrice_tampon_x.nombre_colonnes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				s_matrice_tampon_x.tableau;
	}

/*
--------------------------------------------------------------------------------
  Types icompatibles avec la fonction LSQ
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

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

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

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

	return;
}


/*
================================================================================
  Fonction 'logscale'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_logscale(struct_processus *s_etat_processus)
{
	logical1						presence[3];
	logical1						systeme_auxiliaire;
	logical1						systeme_principal;

	struct_liste_chainee			*l_element_courant;

	struct_objet					*s_objet;

	unsigned char					*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(définition des axes)\n\n");
		}
		else
		{
			printf("(definitions of axes)\n\n");
		}

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

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

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

		printf("    { X Z } LOGSCALE\n");
		printf("    'Y' LOGSCALE\n");

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

	if ((*s_etat_processus).l_base_pile == NULL)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		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) == d_erreur)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	if ((*s_objet).type == NOM)
	{
		tampon = conversion_majuscule((*((struct_nom *) (*s_objet).objet)).nom);

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

		if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y") != 0) &&
				(strcmp(tampon, "Z") != 0))
		{
			liberation(s_etat_processus, s_objet);

			free(tampon);

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

		if (tampon[0] == 'X')
		{
			(*s_etat_processus).echelle_log_x = d_vrai;
		}
		else if (tampon[0] == 'Y')
		{
			(*s_etat_processus).echelle_log_y = d_vrai;
		}
		else
		{
			(*s_etat_processus).echelle_log_z = d_vrai;
		}

		free(tampon);
	}
	else if ((*s_objet).type == LST)
	{
		if ((*s_etat_processus).systeme_axes == 0)
		{
			systeme_principal = d_vrai;
			systeme_auxiliaire = d_faux;
		}
		else
		{
			systeme_principal = d_faux;
			systeme_auxiliaire = d_vrai;
		}

		presence[0] = d_faux;
		presence[1] = d_faux;
		presence[2] = d_faux;

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

		if (l_element_courant == NULL)
		{
			if (systeme_principal == d_vrai)
			{
				(*s_etat_processus).echelle_log_x = d_faux;
				(*s_etat_processus).echelle_log_y = d_faux;
				(*s_etat_processus).echelle_log_z = d_faux;
			}
			else
			{
				(*s_etat_processus).echelle_log_x2 = d_faux;
				(*s_etat_processus).echelle_log_y2 = d_faux;
				(*s_etat_processus).echelle_log_z2 = d_faux;
			}
		}
		else
		{
			while(l_element_courant != NULL)
			{
				if ((*(*l_element_courant).donnee).type != NOM)
				{
					liberation(s_etat_processus, s_objet);

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

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

				if ((strcmp(tampon, "X") != 0) && (strcmp(tampon, "Y") != 0) &&
						(strcmp(tampon, "Z") != 0))
				{
					liberation(s_etat_processus, s_objet);
					free(tampon);

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

				if (tampon[0] == 'X')
				{
					if (presence[0] == d_vrai)
					{
						liberation(s_etat_processus, s_objet);
						free(tampon);

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

					if (systeme_principal == d_vrai)
					{
						(*s_etat_processus).echelle_log_x = d_vrai;
					}

					if (systeme_auxiliaire == d_vrai)
					{
						(*s_etat_processus).echelle_log_x2 = d_vrai;
					}

					presence[0] = d_vrai;
				}
				else if (tampon[0] == 'Y')
				{
					if (presence[1] == d_vrai)
					{
						liberation(s_etat_processus, s_objet);
						free(tampon);

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

					if (systeme_principal == d_vrai)
					{
						(*s_etat_processus).echelle_log_y = d_vrai;
					}

					if (systeme_auxiliaire == d_vrai)
					{
						(*s_etat_processus).echelle_log_y2 = d_vrai;
					}

					presence[1] = d_vrai;
				}
				else
				{
					if (presence[2] == d_vrai)
					{
						liberation(s_etat_processus, s_objet);
						free(tampon);

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

					if (systeme_principal == d_vrai)
					{
						(*s_etat_processus).echelle_log_z = d_vrai;
					}

					if (systeme_auxiliaire == d_vrai)
					{
						(*s_etat_processus).echelle_log_z2 = d_vrai;
					}

					presence[2] = d_vrai;
				}

				l_element_courant = (*l_element_courant).suivant;
				free(tampon);
			}
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet);

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

	liberation(s_etat_processus, s_objet);

	if (test_cfsf(s_etat_processus, 52) == d_faux)
	{
		if ((*s_etat_processus).fichiers_graphiques != NULL)
		{
			appel_gnuplot(s_etat_processus, 'N');
		}
	}

	return;
}

// vim: ts=4