/*
================================================================================
  RPL/2 (R) version 4.1.4
  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 'delete'
================================================================================
  Entrées : pointeur sur une structure struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_delete(struct_processus *s_etat_processus)
{
	const char					*queue;

	file						*fichier;

	integer8					lecture_i64;

	logical1					erreur;
	logical1					existence;
	logical1					ouverture;

	sqlite3_stmt				*ppStmt;

	struct_descripteur_fichier	*descripteur;

	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_indice;

	struct flock				lock;

	struct stat					requete;

	unsigned char				*commande;
	unsigned char				*nom;
	unsigned char				*utf8;

	unsigned long				unite;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(effacement d'un fichier ou d'un enregistrement)\n\n");
		}
		else
		{
			printf("(delete file or record)\n\n");
		}

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

		printf("    2: %s, %s\n", d_CHN, d_INT);
		printf("    1: %s\n", d_FCH);
		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 ((*s_etat_processus).l_base_pile == NULL)
		{
			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
			return;
		}

		if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
		{
			if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
			{
				return;
			}
		}
		else
		{
			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 ((nom = transliteration(s_etat_processus,
				(unsigned char *) (*s_objet_argument).objet,
				d_locale, "UTF-8")) == NULL)
		{
			liberation(s_etat_processus, s_objet_argument);
			return;
		}

		if (stat(nom, &requete) != 0)
		{
			liberation(s_etat_processus, s_objet_argument);
			free(nom);

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

		if (S_ISREG(requete.st_mode)) // Fichier régulier
		{
			if ((fichier = fopen(nom, "r+")) == NULL)
			{
				liberation(s_etat_processus, s_objet_argument);
				free(nom);

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

			lock.l_type = F_WRLCK;
			lock.l_whence = SEEK_SET;
			lock.l_start = 0;
			lock.l_len = 0;
			lock.l_pid = getpid();

			if (fcntl(fileno(fichier), F_GETLK, &lock) == -1)
			{
				free(nom);

				if (fclose(fichier) != 0)
				{
					liberation(s_etat_processus, s_objet_argument);

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

				liberation(s_etat_processus, s_objet_argument);

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

			if (lock.l_type != F_UNLCK)
			{
				liberation(s_etat_processus, s_objet_argument);
				free(nom);

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

			erreur = caracteristiques_fichier(s_etat_processus, nom,
					&existence, &ouverture, &unite);

			if ((erreur != d_absence_erreur) || (ouverture == d_vrai))
			{
				liberation(s_etat_processus, s_objet_argument);
				free(nom);

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

			if (destruction_fichier(nom) == d_erreur)
			{
				liberation(s_etat_processus, s_objet_argument);
				free(nom);

				(*s_etat_processus).erreur_execution =
						d_ex_erreur_acces_fichier;
				return;
			}
		}
		else // Socket
		{
			if (unlink(nom) != 0)
			{
				liberation(s_etat_processus, s_objet_argument);
				free(nom);

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

		free(nom);
	}
	else if ((*s_objet_argument).type == FCH)
	{
		if ((descripteur = descripteur_fichier(s_etat_processus,
				(struct_fichier *) (*s_objet_argument).objet)) == NULL)
		{
			return;
		}

		/*
		 * Vérification des verrous
		 */

		lock.l_type = F_RDLCK;
		lock.l_whence = SEEK_SET;
		lock.l_start = 0;
		lock.l_len = 0;
		lock.l_pid = getpid();

		if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
				== -1)
		{
			liberation(s_etat_processus, s_objet_argument);

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

		if (lock.l_type != F_UNLCK)
		{
			liberation(s_etat_processus, s_objet_argument);

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

		if ((*((struct_fichier *) (*s_objet_argument).objet))
				.protection == 'R')
		{
			liberation(s_etat_processus, s_objet_argument);

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

		if ((*((struct_fichier *) (*s_objet_argument).objet)).binaire == 'N')
		{
			if ((*((struct_fichier *) (*s_objet_argument).objet)).acces
					== 'S')
			{
				liberation(s_etat_processus, s_objet_argument);

				(*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
				return;
			}
			else if ((*((struct_fichier *) (*s_objet_argument).objet)).acces
					== 'D')
			{
				BUG(((*descripteur).type == 'C'), uprintf("Bad filtype !\n"));

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

				if ((*s_objet_indice).type != INT)
				{
					liberation(s_etat_processus, s_objet_argument);
					liberation(s_etat_processus, s_objet_indice);

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

				if (alsprintf(&commande, "select count(*) from data where "
						"id = %lld", (*((integer8 *) (*s_objet_indice).objet)))
						< 0)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
						commande, strlen(commande), &ppStmt, &queue)
						!= SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_step(ppStmt) != SQLITE_ROW)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				lecture_i64 = sqlite3_column_int64(ppStmt, 0);

				if (sqlite3_step(ppStmt) != SQLITE_DONE)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				free(commande);

				if (lecture_i64 == 0)
				{
					liberation(s_etat_processus, s_objet_argument);
					liberation(s_etat_processus, s_objet_indice);

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

				if (alsprintf(&commande, "delete from data where id = %lld",
						(*((integer8 *) (*s_objet_indice).objet))) < 0)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
						commande, strlen(commande), &ppStmt, &queue)
						!= SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_step(ppStmt) != SQLITE_DONE)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				free(commande);
				liberation(s_etat_processus, s_objet_indice);
			}
			else
			{
				BUG(((*descripteur).type == 'C'), uprintf("Bad filtype !\n"));

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

				if ((*s_objet_indice).type != CHN)
				{
					liberation(s_etat_processus, s_objet_argument);
					liberation(s_etat_processus, s_objet_indice);

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

				// Récupération de l'identifiant de la clef

				if ((utf8 = transliteration(s_etat_processus,
						(unsigned char *) (*s_objet_indice).objet, d_locale,
						"UTF-8")) == NULL)
				{
					liberation(s_etat_processus, s_objet_argument);
					liberation(s_etat_processus, s_objet_indice);

					return;
				}

				if (alsprintf(&commande, "select id from key where key = "
						"'{ \"%s\" }'", utf8) < 0)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				free(utf8);

				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
						commande, strlen(commande), &ppStmt, &queue)
						!= SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				switch(sqlite3_step(ppStmt))
				{
					case SQLITE_ROW:
					{
						// Correspondance
						break;
					}

					case SQLITE_DONE:
					{
						// Aucune correspondance
						if (sqlite3_finalize(ppStmt) != SQLITE_OK)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_erreur_fichier;
							return;
						}

						free(commande);

						liberation(s_etat_processus, s_objet_argument);
						liberation(s_etat_processus, s_objet_indice);

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

					default:
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}

				if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				lecture_i64 = sqlite3_column_int64(ppStmt, 0);

				if (sqlite3_step(ppStmt) != SQLITE_DONE)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_erreur_fichier;
					return;
				}

				free(commande);

				if (alsprintf(&commande, "delete from data where key_id = %lld",
						lecture_i64) < 0)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
						commande, strlen(commande), &ppStmt, &queue)
						!= SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_step(ppStmt) != SQLITE_DONE)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_erreur_fichier;
					return;
				}

				free(commande);

				if (alsprintf(&commande, "delete from key where id = %lld",
						lecture_i64) < 0)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
						commande, strlen(commande), &ppStmt, &queue)
						!= SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_step(ppStmt) != SQLITE_DONE)
				{
					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
					return;
				}

				if (sqlite3_finalize(ppStmt) != SQLITE_OK)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_erreur_fichier;
					return;
				}

				free(commande);
				liberation(s_etat_processus, s_objet_indice);
			}
		}
		else // Fichiers non formatés
		{
		}
	}
	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;
}


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

void
instruction_date(struct_processus *s_etat_processus)
{
	struct_objet			*s_objet;

	struct timeval			horodatage;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(information sur la date et l'heure)\n\n");
		}
		else
		{
			printf("(date and time)\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;
		}
	}

	gettimeofday(&horodatage, NULL);

	if ((s_objet = formateur_date(s_etat_processus, &horodatage)) == NULL)
	{
		return;
	}

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

	return;
}


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

void
instruction_drws(struct_processus *s_etat_processus)
{
	file						*fichier;

	int							dimensions;

	logical1					matrice_entiere;

	struct_objet				*s_objet_statistique;

	unsigned char				*nom_fichier;

	unsigned long				j;

	struct_fichier_graphique	*l_fichier_courant;
	struct_fichier_graphique	*l_fichier_precedent;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(affiche une série statistique)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(draw statistical data)\n\n");
			printf("  No argument\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, 0) == d_erreur)
		{
			return;
		}
	}

	/*
	 * Vérification de la présence de la matrice statistique
	 */

	if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
	{
		/*
		 * Aucune variable ds_sdat n'existe.
		 */

		if ((*s_etat_processus).erreur_execution == d_ex)
		{
			(*s_etat_processus).erreur_execution = d_ex_absence_observations;
		}

		(*s_etat_processus).erreur_systeme = d_es;

		return;
	}

	if ((*s_objet_statistique).type == MIN)
	{
		matrice_entiere = d_vrai;
	}
	else if ((*s_objet_statistique).type == MRL)
	{
		matrice_entiere = d_faux;
	}
	else
	{
		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
		return;
	}

	/*
	 * Création du fichier graphique temporaire
	 */

	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 ((fichier = fopen(nom_fichier, "w+")) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	switch((*((struct_matrice *) (*s_objet_statistique).objet)).nombre_colonnes)
	{

	/*
	 * Une seule colonne
	 */

		case 1 :
		{
			dimensions = 2;

			for(j = 0; j < (*((struct_matrice *) (*s_objet_statistique).objet))
					.nombre_lignes; j++)
			{
				if (matrice_entiere == d_vrai)
				{
					if (fprintf(fichier, "%f %f\n", (double) j, (double)
							((integer8 **) (*((struct_matrice *)
							(*s_objet_statistique).objet)).tableau)[j][0]) < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
				else
				{
					if (fprintf(fichier, "%f %f\n", (double) j, (double)
							((real8 **) (*((struct_matrice *)
							(*s_objet_statistique).objet)).tableau)[j][0]) < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
			}

			break;
		}

	/*
	 * Deux colonnes ou plus
	 */

		default :
		{
			dimensions = 2;

			if (((*s_etat_processus).colonne_statistique_1 < 1) ||
					((*s_etat_processus).colonne_statistique_2 < 1) ||
					((*s_etat_processus).colonne_statistique_1 > (signed long)
					(*((struct_matrice *) (*s_objet_statistique).objet))
					.nombre_colonnes) ||
					((*s_etat_processus).colonne_statistique_2 > (signed long)
					(*((struct_matrice *) (*s_objet_statistique).objet))
					.nombre_colonnes))
			{
				if (fclose(fichier) != 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);

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

			for(j = 0; j < (*((struct_matrice *) (*s_objet_statistique).objet))
					.nombre_lignes; j++)
			{
				if (matrice_entiere == d_vrai)
				{
					if (fprintf(fichier, "%f %f\n", (double) ((integer8 **)
							(*((struct_matrice *) (*s_objet_statistique).objet))
							.tableau)[j][(*s_etat_processus)
							.colonne_statistique_1 - 1], (double) ((integer8 **)
							(*((struct_matrice *) (*s_objet_statistique).objet))
							.tableau)[j][(*s_etat_processus)
							.colonne_statistique_2 - 1]) < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
				else
				{
					if (fprintf(fichier, "%f %f\n", (double) ((real8 **)
							(*((struct_matrice *) (*s_objet_statistique).objet))
							.tableau)[j][(*s_etat_processus)
							.colonne_statistique_1 - 1], (double) ((real8 **)
							(*((struct_matrice *) (*s_objet_statistique).objet))
							.tableau)[j][(*s_etat_processus)
							.colonne_statistique_2 - 1]) < 0)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_erreur_fichier;
						return;
					}
				}
			}

			break;
		}
	}

	/*
	 * Fermeture du fichier graphique
	 */

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

	/*
	 * Chaînage du fichier temporaire à la liste des fichiers graphiques
	 */

	l_fichier_courant = (*s_etat_processus).fichiers_graphiques;

	if (l_fichier_courant == NULL)
	{
		if (((*s_etat_processus).fichiers_graphiques = 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 = nom_fichier;
		(*(*s_etat_processus).fichiers_graphiques).legende = NULL;
		(*(*s_etat_processus).fichiers_graphiques).dimensions = dimensions;
		(*(*s_etat_processus).fichiers_graphiques).presence_axes = d_faux;
		(*(*s_etat_processus).fichiers_graphiques).systeme_axes =
				(*s_etat_processus).systeme_axes;
		strcpy((*(*s_etat_processus).fichiers_graphiques).type,
				(*s_etat_processus).type_trace_sigma);
	}
	else
	{
		while(l_fichier_courant != NULL)
		{
			if ((*l_fichier_courant).dimensions != dimensions)
			{
				(*s_etat_processus).erreur_execution =
						d_ex_dimensions_differentes;
				return;
			}

			l_fichier_precedent = l_fichier_courant;
			l_fichier_courant = (*l_fichier_courant).suivant;
		}

		l_fichier_courant = l_fichier_precedent;

		if (((*l_fichier_courant).suivant = 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 = nom_fichier;
		(*l_fichier_courant).legende = NULL;
		(*l_fichier_courant).dimensions = dimensions;
		(*l_fichier_courant).presence_axes = d_faux;
		(*l_fichier_courant).systeme_axes = (*s_etat_processus).systeme_axes;
		strcpy((*l_fichier_courant).type, (*s_etat_processus).type_trace_sigma);
	}

	/*
	 * Affichage du graphique
	 */

	appel_gnuplot(s_etat_processus, 'N');
	(*s_etat_processus).erreur_execution = d_ex;
	(*s_etat_processus).exception = d_ep;

	return;
}


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

void
instruction_decr(struct_processus *s_etat_processus)
{
	logical1					variable_partagee;

	struct_objet				*s_copie_argument;
	struct_objet				*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(décrémentation)\n\n");
		}
		else
		{
			printf("(decrementation)\n\n");
		}

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

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

		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 == INT)
	{
		if ((s_copie_argument = copie_objet(s_etat_processus,
				s_objet_argument, 'O')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		liberation(s_etat_processus, s_objet_argument);
		s_objet_argument = s_copie_argument;

		(*((integer8 *) (*s_objet_argument).objet))--;

		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_argument) == d_erreur)
		{
			return;
		}
	}
	else if ((*s_objet_argument).type == NOM)
	{
		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_argument).objet)).nom) == d_faux)
		{
			(*s_etat_processus).erreur_systeme = d_es;
			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;

			return;
		}

		liberation(s_etat_processus, s_objet_argument);

		if ((*(*s_etat_processus).pointeur_variable_courante)
				.variable_verrouillee == d_vrai)
		{
			(*s_etat_processus).erreur_execution =
					d_ex_variable_verrouillee;
			return;
		}

		if ((*(*s_etat_processus).pointeur_variable_courante).objet
				== NULL)
		{
			if (pthread_mutex_lock(&((*(*s_etat_processus)
					.s_liste_variables_partagees).mutex)) != 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}

			if (recherche_variable_partagee(s_etat_processus,
					(*(*s_etat_processus).pointeur_variable_courante).nom,
					(*(*s_etat_processus).pointeur_variable_courante)
					.variable_partagee, (*(*s_etat_processus)
					.pointeur_variable_courante).origine) == d_faux)
			{
				(*s_etat_processus).erreur_systeme = d_es;
				(*s_etat_processus).erreur_execution =
						d_ex_variable_non_definie;

				return;
			}

			s_objet_argument = (*(*s_etat_processus)
					.s_liste_variables_partagees).table
					[(*(*s_etat_processus).s_liste_variables_partagees)
					.position_variable].objet;
			variable_partagee = d_vrai;
		}
		else
		{
			s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
					.objet;
			variable_partagee = d_faux;
		}

		if ((s_copie_argument = copie_objet(s_etat_processus,
				s_objet_argument, 'O')) == NULL)
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.s_liste_variables_partagees).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

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

		liberation(s_etat_processus, s_objet_argument);

		if (variable_partagee == d_vrai)
		{
			(*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
			(*(*s_etat_processus)
					.s_liste_variables_partagees).table
					[(*(*s_etat_processus).s_liste_variables_partagees)
					.position_variable].objet = s_copie_argument;
		}
		else
		{
			(*(*s_etat_processus).pointeur_variable_courante).objet =
					s_copie_argument;
		}

		if ((*s_copie_argument).type == INT)
		{
			(*((integer8 *) (*s_copie_argument).objet))--;

			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.s_liste_variables_partagees).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}
		else
		{
			if (variable_partagee == d_vrai)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.s_liste_variables_partagees).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

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

		liberation(s_etat_processus, s_objet_argument);
		return;
	}

	return;
}

// vim: ts=4