/*
================================================================================
  RPL/2 (R) version 4.0.22
  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 'slice'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(graphique tridimensionnel avec courbes de niveau)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(3D graph with contour lines)\n\n");
			printf("  No argument\n");
		}

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

#	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

	strcpy((*s_etat_processus).type_trace_eq, "COURBES DE NIVEAU");

	return;
}


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

void
instruction_slicescale(struct_processus *s_etat_processus)
{
	int							automatique;
	int							discret;
	int							incremental;

	long						nombre_arguments;

	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_courant_resultat;

	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_auxiliaire;
	struct_objet				*s_objet_resultat;

	unsigned char				*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(définition des courbes de niveau)\n\n");
		}
		else
		{
			printf("(definition of contour lines)\n\n");
		}

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

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

		printf("    { { Xmin Xmax} { Ymin Ymax } { Zmin Zmax} } SCALE\n");
		printf("    To be fixed!\n");
		/*
		AUTOMATIC
		DISCRETE
		INCREMENTAL
		*/

		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 == LST)
	{
		l_element_courant = (struct_liste_chainee *) (*s_objet_argument).objet;

		automatique = 0;
		discret = 0;
		incremental = 0;

		nombre_arguments = 0;

		while(l_element_courant != NULL)
		{
			if ((*(*l_element_courant).donnee).type == CHN)
			{
				if ((tampon = conversion_majuscule((unsigned char *)
						(*(*l_element_courant).donnee).objet)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (strcmp(tampon, "AUTOMATIC") == 0)
				{
					automatique++;
				}
				else if (strcmp(tampon, "DISCRETE") == 0)
				{
					discret++;
				}
				else if (strcmp(tampon, "INCREMENTAL") == 0)
				{
					incremental++;
				}
				else
				{
					free(tampon);
					liberation(s_etat_processus, s_objet_argument);

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

				free(tampon);
			}

			l_element_courant = (*l_element_courant).suivant;
			nombre_arguments++;
		}

		if ((automatique + discret + incremental) == 1)
		{
			if (automatique == 1)
			{
				if (nombre_arguments > 2)
				{
					liberation(s_etat_processus, s_objet_argument);

					(*s_etat_processus).erreur_execution =
							d_ex_argument_invalide;
					return;
				}
			}
			else if (discret == 1)
			{
				if (nombre_arguments < 2)
				{
					liberation(s_etat_processus, s_objet_argument);

					(*s_etat_processus).erreur_execution =
							d_ex_argument_invalide;
					return;
				}
			}
			else if (incremental == 1)
			{
				if ((nombre_arguments < 3) || (nombre_arguments > 4))
				{
					liberation(s_etat_processus, s_objet_argument);

					(*s_etat_processus).erreur_execution =
							d_ex_argument_invalide;
					return;
				}
			}
			else
			{
				liberation(s_etat_processus, s_objet_argument);

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

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

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

			l_element_courant_resultat = (*s_objet_resultat).objet;
			(*l_element_courant_resultat).suivant = NULL;

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

			if (automatique == 1)
			{
				if (((*(*l_element_courant_resultat).donnee).objet = malloc(
						10 * sizeof(unsigned char))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				strcpy((*(*l_element_courant_resultat).donnee).objet,
						"AUTOMATIC");
			}
			else if (discret == 1)
			{
				if (((*(*l_element_courant_resultat).donnee).objet = malloc(
						9 * sizeof(unsigned char))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

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

				strcpy((*(*l_element_courant_resultat).donnee).objet,
						"INCREMENTAL");
			}

			// Récupération des paramètres numériques

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

			while(l_element_courant != NULL)
			{
				if ((*(*l_element_courant).donnee).type != CHN)
				{
					if (((*(*l_element_courant).donnee).type == ALG) ||
							((*(*l_element_courant).donnee).type == RPN) ||
							((*(*l_element_courant).donnee).type == NOM))
					{
						if (evaluation(s_etat_processus,
								(*l_element_courant).donnee, 'N')
								== d_erreur)
						{
							liberation(s_etat_processus, s_objet_argument);
							liberation(s_etat_processus, s_objet_resultat);

							return;
						}

						if (depilement(s_etat_processus,
								&((*s_etat_processus).l_base_pile),
								&s_objet_auxiliaire) == d_erreur)
						{
							liberation(s_etat_processus, s_objet_argument);
							liberation(s_etat_processus, s_objet_resultat);

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

						liberation(s_etat_processus,
								(*l_element_courant).donnee);
						(*l_element_courant).donnee = s_objet_auxiliaire;
					}

					if (((*(*l_element_courant).donnee).type == INT) ||
							((*(*l_element_courant).donnee).type == REL))
					{
						if (((*l_element_courant_resultat).suivant =
								allocation_maillon(s_etat_processus)) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return;
						}

						l_element_courant_resultat =
								(*l_element_courant_resultat).suivant;
						(*l_element_courant_resultat).suivant = NULL;

						if (((*l_element_courant_resultat).donnee =
								copie_objet(s_etat_processus,
								(*l_element_courant).donnee, 'O'))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return;
						}
					}
					else
					{
						liberation(s_etat_processus, s_objet_argument);
						liberation(s_etat_processus, s_objet_resultat);

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

				l_element_courant = (*l_element_courant).suivant;
			}

			liberation(s_etat_processus,
					(*s_etat_processus).parametres_courbes_de_niveau);
			(*s_etat_processus).parametres_courbes_de_niveau =
					s_objet_resultat;
		}
		else
		{
			liberation(s_etat_processus, s_objet_argument);

			(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
			return;
		}
	}
	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 (test_cfsf(s_etat_processus, 52) == d_faux)
	{
		if ((*s_etat_processus).fichiers_graphiques != NULL)
		{
			appel_gnuplot(s_etat_processus, 'N');
		}
	}

	return;
}


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

void
instruction_sx(struct_processus *s_etat_processus)
{
	logical1							presence_variable;

	long								i;

	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;

	struct_vecteur						*resultat;

	unsigned long						nombre_colonnes;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(somme sur la colonne X)\n\n");
		}
		else
		{
			printf("(sum on X column)\n\n");
		}

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

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

	/*
	 * Recherche d'une variable globale référencée par SIGMA
	 */

	if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
	{
		/*
		 * Aucune variable SIGMA
		 */

		(*s_etat_processus).erreur_systeme = d_es;
		(*s_etat_processus).erreur_execution = d_ex_absence_observations;
		return;
	}
	else
	{
		/*
		 * Il existe une variable locale SIGMA. Reste à vérifier l'existence
		 * d'une variable SIGMA globale...
		 */

		i = (*s_etat_processus).position_variable_courante;
		presence_variable = d_faux;

		while(i >= 0)
		{
			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
					ds_sdat) == 0) && ((*s_etat_processus)
					.s_liste_variables[i].niveau == 1))
			{
				presence_variable = d_vrai;
				break;
			}

			i--;
		}

		if (presence_variable == d_faux)
		{
			(*s_etat_processus).erreur_execution = d_ex_absence_observations;
			return;
		}
		else
		{
			(*s_etat_processus).position_variable_courante = i;

			if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
			{
				(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
				return;
			}

			if (((*((*s_etat_processus).s_liste_variables
					[(*s_etat_processus).position_variable_courante].objet))
					.type != MIN) && ((*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).type != MRL))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_matrice_statistique_invalide;
				return;
			}

			nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).objet))
					.nombre_colonnes;
		}
	}

	if (((*s_etat_processus).colonne_statistique_1 < 1) ||
			((*s_etat_processus).colonne_statistique_1 > (integer8)
			nombre_colonnes))
	{
		(*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
		return;
	}

	s_objet_statistique = ((*s_etat_processus).s_liste_variables
			[(*s_etat_processus).position_variable_courante]).objet;

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((resultat = sommation_colonne_statistique(
				(struct_matrice *) (*s_objet_statistique).objet,
				(*s_etat_processus).colonne_statistique_1)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*resultat).type == 'I')
		{
			(*s_objet_resultat).type = INT;

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

			(*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
					(*resultat).tableau));
		}
		else
		{
			(*s_objet_resultat).type = REL;

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

			(*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
					(*resultat).tableau));
		}

		free((*resultat).tableau);
		free(resultat);

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

	return;
}


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

void
instruction_sy(struct_processus *s_etat_processus)
{
	logical1							presence_variable;

	long								i;

	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;

	struct_vecteur						*resultat;

	unsigned long						nombre_colonnes;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(somme sur la colonne Y)\n\n");
		}
		else
		{
			printf("(sum on Y column)\n\n");
		}

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

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

	/*
	 * Recherche d'une variable globale référencée par SIGMA
	 */

	if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
	{
		/*
		 * Aucune variable SIGMA
		 */

		(*s_etat_processus).erreur_systeme = d_es;
		(*s_etat_processus).erreur_execution = d_ex_absence_observations;
		return;
	}
	else
	{
		/*
		 * Il existe une variable locale SIGMA. Reste à vérifier l'existence
		 * d'une variable SIGMA globale...
		 */

		i = (*s_etat_processus).position_variable_courante;
		presence_variable = d_faux;

		while(i >= 0)
		{
			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
					ds_sdat) == 0) && ((*s_etat_processus)
					.s_liste_variables[i].niveau == 1))
			{
				presence_variable = d_vrai;
				break;
			}

			i--;
		}

		if (presence_variable == d_faux)
		{
			(*s_etat_processus).erreur_execution = d_ex_absence_observations;
			return;
		}
		else
		{
			(*s_etat_processus).position_variable_courante = i;

			if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
			{
				(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
				return;
			}

			if (((*((*s_etat_processus).s_liste_variables
					[(*s_etat_processus).position_variable_courante].objet))
					.type != MIN) && ((*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).type != MRL))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_matrice_statistique_invalide;
				return;
			}

			nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).objet))
					.nombre_colonnes;
		}
	}

	if (((*s_etat_processus).colonne_statistique_2 < 1) ||
			((*s_etat_processus).colonne_statistique_2 > (integer8)
			nombre_colonnes))
	{
		(*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
		return;
	}

	s_objet_statistique = ((*s_etat_processus).s_liste_variables
			[(*s_etat_processus).position_variable_courante]).objet;

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((resultat = sommation_colonne_statistique(
				(struct_matrice *) (*s_objet_statistique).objet,
				(*s_etat_processus).colonne_statistique_2)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*resultat).type == 'I')
		{
			(*s_objet_resultat).type = INT;

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

			(*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
					(*resultat).tableau));
		}
		else
		{
			(*s_objet_resultat).type = REL;

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

			(*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
					(*resultat).tableau));
		}

		free((*resultat).tableau);
		free(resultat);

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

	return;
}


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

void
instruction_sxy(struct_processus *s_etat_processus)
{
	logical1							presence_variable;

	long								i;

	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;

	struct_vecteur						*resultat;

	unsigned long						nombre_colonnes;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(somme des produits des colonne X et Y)\n\n");
		}
		else
		{
			printf("(sum of X and Y colums products)\n\n");
		}

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

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

	/*
	 * Recherche d'une variable globale référencée par SIGMA
	 */

	if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
	{
		/*
		 * Aucune variable SIGMA
		 */

		(*s_etat_processus).erreur_systeme = d_es;
		(*s_etat_processus).erreur_execution = d_ex_absence_observations;
		return;
	}
	else
	{
		/*
		 * Il existe une variable locale SIGMA. Reste à vérifier l'existence
		 * d'une variable SIGMA globale...
		 */

		i = (*s_etat_processus).position_variable_courante;
		presence_variable = d_faux;

		while(i >= 0)
		{
			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
					ds_sdat) == 0) && ((*s_etat_processus)
					.s_liste_variables[i].niveau == 1))
			{
				presence_variable = d_vrai;
				break;
			}

			i--;
		}

		if (presence_variable == d_faux)
		{
			(*s_etat_processus).erreur_execution = d_ex_absence_observations;
			return;
		}
		else
		{
			(*s_etat_processus).position_variable_courante = i;

			if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
			{
				(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
				return;
			}

			if (((*((*s_etat_processus).s_liste_variables
					[(*s_etat_processus).position_variable_courante].objet))
					.type != MIN) && ((*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).type != MRL))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_matrice_statistique_invalide;
				return;
			}

			nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).objet))
					.nombre_colonnes;
		}
	}

	if (((*s_etat_processus).colonne_statistique_1 < 1) ||
			((*s_etat_processus).colonne_statistique_1 > (integer8)
			nombre_colonnes) || ((*s_etat_processus).colonne_statistique_2 < 1)
			|| ((*s_etat_processus).colonne_statistique_2 > (integer8)
			nombre_colonnes))
	{
		(*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
		return;
	}

	s_objet_statistique = ((*s_etat_processus).s_liste_variables
			[(*s_etat_processus).position_variable_courante]).objet;

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((resultat = sommation_produits_colonnes_statistiques(
				(struct_matrice *) (*s_objet_statistique).objet,
				(*s_etat_processus).colonne_statistique_1,
				(*s_etat_processus).colonne_statistique_2)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*resultat).type == 'I')
		{
			(*s_objet_resultat).type = INT;

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

			(*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
					(*resultat).tableau));
		}
		else
		{
			(*s_objet_resultat).type = REL;

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

			(*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
					(*resultat).tableau));
		}

		free((*resultat).tableau);
		free(resultat);

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

	return;
}


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

void
instruction_sx2(struct_processus *s_etat_processus)
{
	logical1							presence_variable;

	long								i;

	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;

	struct_vecteur						*resultat;

	unsigned long						nombre_colonnes;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(somme des carrés de la colonne X)\n\n");
		}
		else
		{
			printf("(sum of column X squares)\n\n");
		}

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

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

	/*
	 * Recherche d'une variable globale référencée par SIGMA
	 */

	if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
	{
		/*
		 * Aucune variable SIGMA
		 */

		(*s_etat_processus).erreur_systeme = d_es;
		(*s_etat_processus).erreur_execution = d_ex_absence_observations;
		return;
	}
	else
	{
		/*
		 * Il existe une variable locale SIGMA. Reste à vérifier l'existence
		 * d'une variable SIGMA globale...
		 */

		i = (*s_etat_processus).position_variable_courante;
		presence_variable = d_faux;

		while(i >= 0)
		{
			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
					ds_sdat) == 0) && ((*s_etat_processus)
					.s_liste_variables[i].niveau == 1))
			{
				presence_variable = d_vrai;
				break;
			}

			i--;
		}

		if (presence_variable == d_faux)
		{
			(*s_etat_processus).erreur_execution = d_ex_absence_observations;
			return;
		}
		else
		{
			(*s_etat_processus).position_variable_courante = i;

			if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
			{
				(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
				return;
			}

			if (((*((*s_etat_processus).s_liste_variables
					[(*s_etat_processus).position_variable_courante].objet))
					.type != MIN) && ((*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).type != MRL))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_matrice_statistique_invalide;
				return;
			}

			nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).objet))
					.nombre_colonnes;
		}
	}

	if (((*s_etat_processus).colonne_statistique_1 < 1) ||
			((*s_etat_processus).colonne_statistique_1 > (integer8)
			nombre_colonnes))
	{
		(*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
		return;
	}

	s_objet_statistique = ((*s_etat_processus).s_liste_variables
			[(*s_etat_processus).position_variable_courante]).objet;

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((resultat = sommation_produits_colonnes_statistiques(
				(struct_matrice *) (*s_objet_statistique).objet,
				(*s_etat_processus).colonne_statistique_1,
				(*s_etat_processus).colonne_statistique_1)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*resultat).type == 'I')
		{
			(*s_objet_resultat).type = INT;

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

			(*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
					(*resultat).tableau));
		}
		else
		{
			(*s_objet_resultat).type = REL;

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

			(*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
					(*resultat).tableau));
		}

		free((*resultat).tableau);
		free(resultat);

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

	return;
}


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

void
instruction_sy2(struct_processus *s_etat_processus)
{
	logical1							presence_variable;

	long								i;

	struct_objet						*s_objet_statistique;
	struct_objet						*s_objet_resultat;

	struct_vecteur						*resultat;

	unsigned long						nombre_colonnes;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(somme des carrés de la colonne Y)\n\n");
		}
		else
		{
			printf("(sum of column Y squares)\n\n");
		}

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

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

	/*
	 * Recherche d'une variable globale référencée par SIGMA
	 */

	if (recherche_variable(s_etat_processus, ds_sdat) == d_faux)
	{
		/*
		 * Aucune variable SIGMA
		 */

		(*s_etat_processus).erreur_systeme = d_es;
		(*s_etat_processus).erreur_execution = d_ex_absence_observations;
		return;
	}
	else
	{
		/*
		 * Il existe une variable locale SIGMA. Reste à vérifier l'existence
		 * d'une variable SIGMA globale...
		 */

		i = (*s_etat_processus).position_variable_courante;
		presence_variable = d_faux;

		while(i >= 0)
		{
			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
					ds_sdat) == 0) && ((*s_etat_processus)
					.s_liste_variables[i].niveau == 1))
			{
				presence_variable = d_vrai;
				break;
			}

			i--;
		}

		if (presence_variable == d_faux)
		{
			(*s_etat_processus).erreur_execution = d_ex_absence_observations;
			return;
		}
		else
		{
			(*s_etat_processus).position_variable_courante = i;

			if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
			{
				(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
				return;
			}

			if (((*((*s_etat_processus).s_liste_variables
					[(*s_etat_processus).position_variable_courante].objet))
					.type != MIN) && ((*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).type != MRL))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_matrice_statistique_invalide;
				return;
			}

			nombre_colonnes = (*((struct_matrice *) (*((*s_etat_processus)
					.s_liste_variables[(*s_etat_processus)
					.position_variable_courante].objet)).objet))
					.nombre_colonnes;
		}
	}

	if (((*s_etat_processus).colonne_statistique_2 < 1) ||
			((*s_etat_processus).colonne_statistique_2 > (integer8)
			nombre_colonnes))
	{
		(*s_etat_processus).erreur_execution = d_ex_observations_inexistantes;
		return;
	}

	s_objet_statistique = ((*s_etat_processus).s_liste_variables
			[(*s_etat_processus).position_variable_courante]).objet;

	if (((*s_objet_statistique).type == MIN) ||
			((*s_objet_statistique).type == MRL))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, NON)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((resultat = sommation_produits_colonnes_statistiques(
				(struct_matrice *) (*s_objet_statistique).objet,
				(*s_etat_processus).colonne_statistique_2,
				(*s_etat_processus).colonne_statistique_2)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*resultat).type == 'I')
		{
			(*s_objet_resultat).type = INT;

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

			(*((integer8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
					(*resultat).tableau));
		}
		else
		{
			(*s_objet_resultat).type = REL;

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

			(*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
					(*resultat).tableau));
		}

		free((*resultat).tableau);
		free(resultat);

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

	return;
}

// vim: ts=4