/*
================================================================================
  RPL/2 (R) version 4.0.18
  Copyright (C) 1989-2010 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 'crmtx'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_crmtx(struct_processus *s_etat_processus)
{
	pthread_mutexattr_t				attributs_mutex;

	struct_liste_chainee			*s_mutex;

	struct_objet					*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(création d'un mutex)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(create mutex)\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;
		}
	}

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

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

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
	pthread_mutex_init(&((*((struct_mutex *) (*s_objet).objet)).mutex),
			&attributs_mutex);
	pthread_mutexattr_destroy(&attributs_mutex);

	if (((*s_mutex).donnee = copie_objet(s_etat_processus, s_objet, 'P'))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

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

	if (pthread_mutex_lock(&((*s_etat_processus).protection_liste_mutexes))
			!= 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	(*s_mutex).suivant = (*s_etat_processus).liste_mutexes;
	(*s_etat_processus).liste_mutexes = s_mutex;

	if (pthread_mutex_unlock(&((*s_etat_processus).protection_liste_mutexes))
			!= 0)
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	return;
}


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

void
instruction_clrmtx(struct_processus *s_etat_processus)
{
	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_precedent;

	struct_objet				*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(destruction d'un mutex)\n\n");
		}
		else
		{
			printf("(clear mutex)\n\n");
		}

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

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

	if ((*s_objet).type == MTX)
	{
		l_element_precedent = NULL;
		l_element_courant = (*s_etat_processus).liste_mutexes;

		while(l_element_courant != NULL)
		{
			if (&((*((struct_mutex *) (*s_objet).objet)).mutex) ==
					&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
					.mutex))
			{
				if (l_element_precedent == NULL)
				{
					(*s_etat_processus).liste_mutexes =
							(*l_element_courant).suivant;
				}
				else if ((*l_element_courant).suivant == NULL)
				{
					(*l_element_precedent).suivant = NULL;
				}
				else
				{
					(*l_element_precedent).suivant =
							(*l_element_courant).suivant;
				}

				liberation(s_etat_processus, (*l_element_courant).donnee);
				free(l_element_courant);

				break;
			}

			l_element_precedent = l_element_courant;
			l_element_courant = (*l_element_courant).suivant;
		}

		if (l_element_courant == NULL)
		{
			liberation(s_etat_processus, s_objet);

			(*s_etat_processus).erreur_execution = d_ex_mutex;
			return;
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet);

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

	liberation(s_etat_processus, s_objet);

	return;
}


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

void
instruction_copy(struct_processus *s_etat_processus)
{
	struct_objet					*s_objet_argument;
	struct_objet					*s_objet_resultat;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(création d'une nouvelle instance d'un objet)\n\n");
		}
		else
		{
			printf("(create new object instance)\n\n");
		}

		printf("    1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s,\n"
				"       %s, %s\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
				d_SQL, d_SLB, d_PRC, d_MTX);
		printf("->  1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s,\n"
				"       %s, %s\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
				d_SQL, d_SLB, d_PRC, d_MTX);

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

	s_objet_resultat = copie_objet(s_etat_processus, s_objet_argument, 'O');
	liberation(s_etat_processus, s_objet_argument);

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

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

	return;
}


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

void
instruction_crsmphr(struct_processus *s_etat_processus)
{
	sem_t							*semaphore;

	struct_objet					*s_objet_argument_1;
	struct_objet					*s_objet_argument_2;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(création d'un sémaphore nommé)\n\n");
		}
		else
		{
			printf("(create named semaphore)\n\n");
		}

		printf("    2: %s\n", d_INT);
		printf("    1: %s\n", d_CHN);
		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;
	}

	if (((*s_objet_argument_1).type == CHN) &&
			((*s_objet_argument_2).type == INT))
	{
		if ((semaphore = sem_open((unsigned char *) (*s_objet_argument_1).objet,
				O_CREAT | O_EXCL, S_IRUSR | S_IWUSR,
				(int) (*((integer8 *) (*s_objet_argument_2).objet)))) ==
				SEM_FAILED)
		{
			(*s_etat_processus).erreur_execution = d_ex_semaphore;

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

			return;
		}

		if (sem_close(semaphore) != 0)
		{
			(*s_etat_processus).erreur_execution = d_ex_semaphore;

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

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

	return;
}


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

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

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(destruction d'un sémaphore nommé)\n\n");
		}
		else
		{
			printf("(delete named semaphore)\n\n");
		}

		printf("    1: %s\n", d_CHN);
		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 (sem_unlink((unsigned char *) (*s_objet_argument).objet) != 0)
		{
			(*s_etat_processus).erreur_execution = d_ex_semaphore;

			liberation(s_etat_processus, s_objet_argument);
			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);

	return;
}


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

void
instruction_cond(struct_processus *s_etat_processus)
{
	struct_objet					*s_objet_argument;
	struct_objet					*s_objet_resultat;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(nombre de condition d'une matrice)\n\n");
		}
		else
		{
			printf("(matrix condition number)\n\n");
		}

		printf("    1: %s, %s, %s\n", d_MIN, d_MRL, d_MCX);
		printf("->  1: %s\n", 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, 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 == MIN) ||
			((*s_objet_argument).type == MRL) ||
			((*s_objet_argument).type == MCX))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		cond(s_etat_processus, (*s_objet_argument).objet,
				(*s_objet_resultat).objet);

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

		if (((*s_etat_processus).erreur_execution != d_ex) ||
				((*s_etat_processus).exception != d_ep))
		{
			liberation(s_etat_processus, s_objet_argument);
			liberation(s_etat_processus, s_objet_resultat);
			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 (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat) == d_erreur)
	{
		return;
	}

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(réinitialisation des erreurs)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(error reinitialization)\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;
		}
	}

	(*s_etat_processus).derniere_exception = d_ep;
	(*s_etat_processus).derniere_erreur_execution = d_ex;
	(*s_etat_processus).derniere_erreur_systeme = d_es;

	return;
}


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

void
instruction_currenc(struct_processus *s_etat_processus)
{
	struct_objet					*s_objet_resultat;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(encodage interne des chaînes de caractères)\n\n");
		}
		else
		{
			printf("(internal strings encodage)\n\n");
		}

		printf("->  1: %s\n", d_CHN);
		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, CHN)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	if (((*s_objet_resultat).objet = malloc((strlen(d_locale) + 1) *
			sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	strcpy((unsigned char *) (*s_objet_resultat).objet, d_locale);

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

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(suppression de la fonction de terminaison)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(delete task terminaison function)\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;
		}
	}

	liberation(s_etat_processus, (*s_etat_processus).at_exit);
	(*s_etat_processus).at_exit = NULL;

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(suppression de la fonction de contrôle d'injection)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(delete injection controle function)\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;
		}
	}

	liberation(s_etat_processus, (*s_etat_processus).at_poke);
	(*s_etat_processus).at_poke = NULL;

	return;
}

// vim: ts=4