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

void
instruction_sort(struct_processus *s_etat_processus)
{
	integer8					i;
	integer8					j;
	integer8					nombre_elements;

	logical1					condition;
	logical1					inversion;
	logical1					presence_nom;
	logical1					terminaison_boucle_1;
	logical1					terminaison_boucle_2;
	logical1					terminaison_boucle_3;
	logical1					variable_partagee;

	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_precedent;
	struct_liste_chainee		*l_element_tampon;

	struct_objet				*s_objet_copie;
	struct_objet				*s_objet_critere;
	struct_objet				*s_objet_liste;
	struct_objet				*s_objet_registre;
	struct_objet				*s_objet_test;

	integer8					ecartement;
	integer8					indice_i;
	integer8					indice_j;
	integer8					indice_k;
	integer8					indice_l;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(trie une liste selon un critère paramétrable)\n\n");
		}
		else
		{
			printf("(sort a list)\n\n");
		}

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

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

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

		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_critere) == 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_liste) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_critere);

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

	variable_partagee = d_faux;

	if ((*s_objet_liste).type == NOM)
	{
		if (recherche_variable(s_etat_processus, (*((struct_nom *)
				(*s_objet_liste).objet)).nom) == d_faux)
		{
			(*s_etat_processus).erreur_systeme = d_es;
			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;

			liberation(s_etat_processus, s_objet_critere);
			liberation(s_etat_processus, s_objet_liste);

			return;
		}

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

			liberation(s_etat_processus, s_objet_critere);
			liberation(s_etat_processus, s_objet_liste);

			return;
		}

		if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
		{
			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) == NULL)
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_type_argument;

				liberation(s_etat_processus, s_objet_critere);
				liberation(s_etat_processus, s_objet_liste);

				return;
			}

			if (((*(*(*s_etat_processus).pointeur_variable_partagee_courante)
					.objet).type != LST) && ((*(*(*s_etat_processus)
					.pointeur_variable_partagee_courante).objet).type != TBL))
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				(*s_etat_processus).erreur_execution =
						d_ex_erreur_type_argument;

				liberation(s_etat_processus, s_objet_critere);
				liberation(s_etat_processus, s_objet_liste);

				return;
			}

			liberation(s_etat_processus, s_objet_liste);

			s_objet_liste = (*(*s_etat_processus)
					.pointeur_variable_partagee_courante).objet;

			if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
					'N')) == NULL)
			{
				if (pthread_mutex_unlock(&((*(*s_etat_processus)
						.pointeur_variable_partagee_courante).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

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

			variable_partagee = d_vrai;
		}
		else
		{
			if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
					.type != LST) && ((*(*(*s_etat_processus)
					.pointeur_variable_courante).objet).type != TBL))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_type_argument;

				liberation(s_etat_processus, s_objet_critere);
				liberation(s_etat_processus, s_objet_liste);

				return;
			}

			liberation(s_etat_processus, s_objet_liste);

			s_objet_liste = (*(*s_etat_processus).pointeur_variable_courante)
					.objet;

			if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
					'N')) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}

		liberation(s_etat_processus, s_objet_liste);
		s_objet_liste = s_objet_copie;
		(*(*s_etat_processus).pointeur_variable_courante).objet = s_objet_liste;
		presence_nom = d_vrai;
	}
	else
	{
		if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste, 'N'))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		liberation(s_etat_processus, s_objet_liste);
		s_objet_liste = s_objet_copie;
		presence_nom = d_faux;
	}

	if (((*s_objet_liste).type == LST) &&
			((*s_objet_critere).type == RPN))
	{
		/*
		 * Tri bulle de la liste chaînée. On se contente d'un tri bulle
		 * car on travaille sur une liste chaînée et non sur un tableau
		 * sur lequel on pourrait accéder directement aux données grâce à
		 * leur indice.
		 */

		nombre_elements = 0;
		l_element_courant = (*s_objet_liste).objet;

		while(l_element_courant != NULL)
		{
			l_element_courant = (*l_element_courant).suivant;
			nombre_elements++;
		}

		// Si la liste est vide, on considère qu'elle est triée.
		// De la même manière, on considère qu'une liste d'un
		// seul élément est toujours triée.

		if (nombre_elements > 1)
		{
			j = nombre_elements;

			do
			{
				inversion = d_faux;

				l_element_courant = (*s_objet_liste).objet;
				l_element_precedent = NULL;

				for(i = 0; i < j - 1; i++)
				{
					// Test des éléments adjacents. Pour cela, on
					// empile les deux éléments adjacents dans la pile dans
					// l'ordre [i] [i+1] et on évalue le critère d'ordre.

					if ((s_objet_copie = copie_objet(s_etat_processus,
							(*l_element_courant).donnee, '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_copie) == d_erreur)
					{
						return;
					}

					if ((s_objet_copie = copie_objet(s_etat_processus,
							(*(*l_element_courant)
							.suivant).donnee, '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_copie) == d_erreur)
					{
						return;
					}

					if (evaluation(s_etat_processus, s_objet_critere, 'N')
							== d_erreur)
					{
						liberation(s_etat_processus, s_objet_critere);
						liberation(s_etat_processus, s_objet_liste);

						return;
					}

					if (depilement(s_etat_processus,
							&((*s_etat_processus).l_base_pile), &s_objet_test)
							== d_erreur)
					{
						liberation(s_etat_processus, s_objet_critere);
						liberation(s_etat_processus, s_objet_liste);

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

					if ((*s_objet_test).type == INT)
					{
						condition = ((*((integer8 *) (*s_objet_test).objet))
								== 0) ? d_faux : d_vrai;
					}
					else if ((*s_objet_test).type == REL)
					{
						condition = ((*((real8 *) (*s_objet_test).objet))
								== 0) ? d_faux : d_vrai;
					}
					else
					{
						liberation(s_etat_processus, s_objet_critere);
						liberation(s_etat_processus, s_objet_liste);
						liberation(s_etat_processus, s_objet_test);

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

					liberation(s_etat_processus, s_objet_test);

					if (condition == d_faux)
					{
						// On échange les deux éléments adjacents

						inversion = d_vrai;

						if (l_element_precedent == NULL)
						{
							// Échange des deux premiers éléments
							// de la liste.

							l_element_tampon = (*(*l_element_courant)
									.suivant).suivant;
							(*s_objet_liste).objet = (*l_element_courant)
									.suivant;
							(*((struct_liste_chainee *) (*s_objet_liste)
									.objet)).suivant = l_element_courant;
							(*l_element_courant).suivant =
									l_element_tampon;
							l_element_courant = (*s_objet_liste).objet;
						}
						else
						{
							// Échange de deux éléments quelconques de la
							// liste.

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

							l_element_courant = l_element_tampon;
						}
					}

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

				j--;
			} while(inversion != d_faux);
		}
	}
	else if (((*s_objet_liste).type == TBL) &&
			((*s_objet_critere).type == RPN))
	{
		/*
		 * Tri Shell-Metzner d'une table
		 */

		ecartement = (*((struct_tableau *) (*s_objet_liste).objet))
				.nombre_elements;
		terminaison_boucle_1 = d_faux;

		do
		{
			ecartement = ecartement / 2;

			if (ecartement >= 1)
			{
				indice_j = 0;
				indice_k = (*((struct_tableau *) (*s_objet_liste).objet))
						.nombre_elements - ecartement;
				terminaison_boucle_2 = d_faux;

				do
				{
					indice_i = indice_j;
					terminaison_boucle_3 = d_faux;

					do
					{
						indice_l = indice_i + ecartement;

						if ((indice_i > 0) && (indice_l > 0))
						{
							if ((s_objet_copie = copie_objet(s_etat_processus,
									(*((struct_tableau *) (*s_objet_liste)
									.objet)).elements[indice_i - 1], '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_copie) == d_erreur)
							{
								return;
							}

							if ((s_objet_copie = copie_objet(s_etat_processus,
									(*((struct_tableau *) (*s_objet_liste)
									.objet)).elements[indice_l - 1], '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_copie) == d_erreur)
							{
								return;
							}

							if (evaluation(s_etat_processus, s_objet_critere,
									'N') == d_erreur)
							{
								liberation(s_etat_processus, s_objet_critere);
								liberation(s_etat_processus, s_objet_liste);

								return;
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									&s_objet_test) == d_erreur)
							{
								liberation(s_etat_processus, s_objet_critere);
								liberation(s_etat_processus, s_objet_liste);

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

							if ((*s_objet_test).type == INT)
							{
								condition = ((*((integer8 *) (*s_objet_test)
										.objet)) == 0) ? d_faux : d_vrai;
							}
							else if ((*s_objet_test).type == REL)
							{
								condition = ((*((real8 *) (*s_objet_test)
										.objet)) == 0) ? d_faux : d_vrai;
							}
							else
							{
								liberation(s_etat_processus, s_objet_critere);
								liberation(s_etat_processus, s_objet_liste);
								liberation(s_etat_processus, s_objet_test);

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

							liberation(s_etat_processus, s_objet_test);

							if (condition == d_faux)
							{
								s_objet_registre =
										(*((struct_tableau *)
										(*s_objet_liste).objet)).elements
										[indice_i - 1];
								(*((struct_tableau *) (*s_objet_liste).objet))
										.elements[indice_i - 1] =
										(*((struct_tableau *) (*s_objet_liste)
										.objet)).elements[indice_l - 1];
								(*((struct_tableau *) (*s_objet_liste)
										.objet)).elements[indice_l - 1] =
										s_objet_registre;

								indice_i -= ecartement;

								if (indice_i < 1)
								{
									terminaison_boucle_3 = d_vrai;
								}
							}
							else
							{
								terminaison_boucle_3 = d_vrai;
							}
						}
						else
						{
							terminaison_boucle_3 = d_vrai;
						}
					} while(terminaison_boucle_3 == d_faux);

					indice_j++;

					if (indice_j > indice_k)
					{
						terminaison_boucle_2 = d_vrai;
					}
				} while(terminaison_boucle_2 == d_faux);
			}
			else
			{
				terminaison_boucle_1 = d_vrai;
			}
		} while(terminaison_boucle_1 == d_faux);
	}
	else
	{
		if (pthread_mutex_unlock(&((*(*s_etat_processus)
				.pointeur_variable_partagee_courante).mutex)) != 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		liberation(s_etat_processus, s_objet_liste);
		liberation(s_etat_processus, s_objet_critere);

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

	if (presence_nom == d_faux)
	{
		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				s_objet_liste) == d_erreur)
		{
			return;
		}
	}
	else
	{
		if (variable_partagee == d_vrai)
		{
			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
					s_objet_liste;

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

	liberation(s_etat_processus, s_objet_critere);

	return;
}


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

void
instruction_save(struct_processus *s_etat_processus)
{
	struct_objet						*s_objet_1;
	struct_objet						*s_objet_2;

	struct_variable						s_variable;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(affecte un objet à une variable globale)\n\n");
		}
		else
		{
			printf("(store an object in a global variable)\n\n");
		}

		printf("    2: %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\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, 2) == d_erreur)
		{
			return;
		}
	}

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_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_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_1);

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

	if ((*s_objet_1).type != NOM)
	{
		liberation(s_etat_processus, s_objet_1);
		liberation(s_etat_processus, s_objet_2);

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

	if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
			(*s_objet_1).objet)).nom) == d_vrai)
	{
		/*
		 * Une variable est accessible.
		 */

		if ((*(*s_etat_processus).pointeur_variable_courante)
				.variable_verrouillee == d_vrai)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

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

		liberation(s_etat_processus,
				(*(*s_etat_processus).pointeur_variable_courante).objet);
		(*(*s_etat_processus).pointeur_variable_courante).objet = s_objet_2;
	}
	else
	{
		/*
		 * Aucune variable n'est accessible (ni locale, ni globale).
		 */

		if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
				((*((struct_nom *) (*s_objet_1).objet)).symbole == d_faux))
		{
			liberation(s_etat_processus, s_objet_1);
			liberation(s_etat_processus, s_objet_2);

			(*s_etat_processus).erreur_systeme = d_es;
			(*s_etat_processus).erreur_execution =
					d_ex_creation_variable_globale;
			return;
		}

		if ((s_variable.nom = malloc((strlen((*((struct_nom *)
				(*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy(s_variable.nom, (*((struct_nom *) (*s_objet_1).objet)).nom);
		s_variable.niveau = 1;

		/*
		 * Le niveau 0 correspond aux définitions. Les variables
		 * commencent à 1 car elles sont toujours incluses dans
		 * une définition.
		 */

		s_variable.objet = s_objet_2;

		if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')
				== d_erreur)
		{
			return;
		}

		(*s_etat_processus).erreur_systeme = d_es;
	}

	liberation(s_etat_processus, s_objet_1);

	return;
}


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

void
instruction_suspend(struct_processus *s_etat_processus)
{
	struct timespec				attente;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(attend un signal RPL/SIGCONT)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(wait for RPL/SIGCONT signal)\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_etat_processus).profilage == d_vrai)
	{
		profilage(s_etat_processus, "Suspend");

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

#	ifndef SEMAPHORES_NOMMES
		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#	else
		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#	endif
	{
		(*s_etat_processus).erreur_systeme = d_es_processus;
		return;
	}

	for((*s_etat_processus).redemarrage_processus = d_faux;;)
	{
		scrutation_interruptions(s_etat_processus);

		if ((*s_etat_processus).redemarrage_processus == d_vrai)
		{
			break;
		}

		nanosleep(&attente, NULL);
		INCR_GRANULARITE(attente.tv_nsec);
	}

#	ifndef SEMAPHORES_NOMMES
		while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#	else
		while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#	endif
	{
		if (errno != EINTR)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	if ((*s_etat_processus).profilage == d_vrai)
	{
		profilage(s_etat_processus, NULL);
	}

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(déclaration de variables statiques)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(static variables declaration)\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_etat_processus).creation_variables_partagees == d_vrai)
	{
		(*s_etat_processus).erreur_execution = d_ex_variable_statique_partagee;
		return;
	}

	(*s_etat_processus).creation_variables_statiques = d_vrai;

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(déclaration de variables partagées)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(shared variables declaration)\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_etat_processus).creation_variables_partagees == d_vrai)
	{
		(*s_etat_processus).erreur_execution = d_ex_variable_statique_partagee;
		return;
	}

	(*s_etat_processus).creation_variables_partagees = d_vrai;

	return;
}


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

void
instruction_stoswi(struct_processus *s_etat_processus)
{
	integer8					interruption;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(définition d'une interruption logicielle)\n\n");
		}
		else
		{
			printf("(software interrupt definition)\n\n");
		}

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

		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 == INT)
	{
		interruption = (*((integer8 *) (*s_objet_argument_1).objet));

		if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if ((*s_objet_argument_2).type == NOM)
		{
			liberation(s_etat_processus, (*s_etat_processus).corps_interruptions
					[interruption - 1]);
			(*s_etat_processus).corps_interruptions[interruption - 1] =
					s_objet_argument_2;
		}
		else if((*s_objet_argument_2).type == RPN)
		{
			liberation(s_etat_processus, (*s_etat_processus).corps_interruptions
					[interruption - 1]);
			(*s_etat_processus).corps_interruptions[interruption - 1] =
					s_objet_argument_2;
		}
		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;
		}
	}
	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);

	return;
}


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

void
instruction_swi(struct_processus *s_etat_processus)
{
	int							interruption_reduite;

	integer8					interruption;

	sig_atomic_t				registre;

	ssize_t						longueur_ecriture;

	struct_objet				*s_objet_argument;

	struct timespec				attente;

	unsigned char				caractere;
	unsigned char				tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(interruption logicielle)\n\n");
		}
		else
		{
			printf("(software interrupt)\n\n");
		}

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

		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)
	{
		interruption = (*((integer8 *) (*s_objet_argument).objet));

		if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
		{
			liberation(s_etat_processus, s_objet_argument);

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

		if ((*s_etat_processus).presence_pipes == d_faux)
		{
			liberation(s_etat_processus, s_objet_argument);

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

		// Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
		// de surveillance.

		registre = (*s_etat_processus).var_volatile_traitement_retarde_stop;
		(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;

		interruption_reduite = (int) interruption;

		attente.tv_sec = 0;
		attente.tv_nsec = GRANULARITE_us * 1000;

#		ifndef SEMAPHORES_NOMMES
			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#		else
			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#		endif
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		while((longueur_ecriture = write_atomic(s_etat_processus,
				(*s_etat_processus).pipe_interruptions,
				&interruption_reduite, sizeof(interruption_reduite)))
				!= sizeof(interruption_reduite))
		{
#			ifndef SEMAPHORES_NOMMES
				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				if (errno != EINTR)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			if (longueur_ecriture == -1)
			{
				if (registre == 0)
				{
					if ((*s_etat_processus)
							.var_volatile_traitement_retarde_stop == -1)
					{
						(*s_etat_processus).var_volatile_requete_arret = -1;
					}

					(*s_etat_processus)
							.var_volatile_traitement_retarde_stop
							= registre;
				}

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

			nanosleep(&attente, NULL);
			INCR_GRANULARITE(attente.tv_nsec);

#			ifndef SEMAPHORES_NOMMES
				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}

			scrutation_interruptions(s_etat_processus);
		}

#		ifndef SEMAPHORES_NOMMES
			while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#		else
			while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#		endif
		{
			if (errno != EINTR)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}

		if ((*s_etat_processus).processus_detache == d_vrai)
		{
			caractere = 2;

			attente.tv_sec = 0;
			attente.tv_nsec = GRANULARITE_us * 1000;

#			ifndef SEMAPHORES_NOMMES
				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_etat_processus).pipe_nombre_elements_attente,
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
#				ifndef SEMAPHORES_NOMMES
					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#				else
					while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#				endif
				{
					if (errno != EINTR)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

				if (longueur_ecriture == -1)
				{
					if (registre == 0)
					{
						if ((*s_etat_processus)
								.var_volatile_traitement_retarde_stop == -1)
						{
							(*s_etat_processus).var_volatile_requete_arret = -1;
						}

						(*s_etat_processus)
								.var_volatile_traitement_retarde_stop
								= registre;
					}

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

				nanosleep(&attente, NULL);
				INCR_GRANULARITE(attente.tv_nsec);

#				ifndef SEMAPHORES_NOMMES
					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#				else
					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#				endif
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				scrutation_interruptions(s_etat_processus);
			}

#			ifndef SEMAPHORES_NOMMES
				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				if (errno != EINTR)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}
		else
		{
			caractere = 2;

#			ifndef SEMAPHORES_NOMMES
				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}

			while((longueur_ecriture = write_atomic(s_etat_processus,
					(*s_etat_processus).pipe_nombre_elements_attente,
					&caractere, sizeof(caractere))) != sizeof(caractere))
			{
#				ifndef SEMAPHORES_NOMMES
					while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#				else
					while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#				endif
				{
					if (errno != EINTR)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

				if (longueur_ecriture == -1)
				{
					if (registre == 0)
					{
						if ((*s_etat_processus)
								.var_volatile_traitement_retarde_stop == -1)
						{
							(*s_etat_processus).var_volatile_requete_arret = -1;
						}

						(*s_etat_processus)
								.var_volatile_traitement_retarde_stop
								= registre;
					}

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

				nanosleep(&attente, NULL);
				INCR_GRANULARITE(attente.tv_nsec);

#				ifndef SEMAPHORES_NOMMES
					if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#				else
					if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#				endif
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				scrutation_interruptions(s_etat_processus);
			}

#			ifndef SEMAPHORES_NOMMES
				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				if (errno != EINTR)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}

		attente.tv_sec = 0;
		attente.tv_nsec = GRANULARITE_us * 1000;

#		ifndef SEMAPHORES_NOMMES
			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#		else
			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#		endif
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}

		while(read_atomic(s_etat_processus,
				(*s_etat_processus).pipe_acquittement,
				&tampon, sizeof(unsigned char)) != sizeof(unsigned char))
		{
#			ifndef SEMAPHORES_NOMMES
				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				if (errno != EINTR)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			nanosleep(&attente, NULL);
			INCR_GRANULARITE(attente.tv_nsec);

#			ifndef SEMAPHORES_NOMMES
				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
#			else
				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
#			endif
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}

			scrutation_interruptions(s_etat_processus);
		}

#		ifndef SEMAPHORES_NOMMES
			while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
#		else
			while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
#		endif
		{
			if (errno != EINTR)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}

		if (registre == 0)
		{
			if ((*s_etat_processus).var_volatile_traitement_retarde_stop == -1)
			{
				(*s_etat_processus).var_volatile_requete_arret = -1;
			}

			(*s_etat_processus).var_volatile_traitement_retarde_stop = registre;
		}
	}
	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 'swilock'
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_swilock(struct_processus *s_etat_processus)
{
	integer8					interruption;

	struct_liste_chainee		*l_element_courant;

	struct_objet				*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(verrouillage des interruptions logicielles)\n\n");
		}
		else
		{
			printf("(software interrupt lock)\n\n");
		}

		printf("    1: %s, %s\n", d_INT, 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, 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)
	{
		interruption = (*((integer8 *) (*s_objet_argument).objet));

		if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
		{
			liberation(s_etat_processus, s_objet_argument);

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

		(*s_etat_processus).masque_interruptions[interruption - 1] = 'I';
	}
	else if ((*s_objet_argument).type == LST)
	{
		l_element_courant = (*s_objet_argument).objet;

		while(l_element_courant)
		{
			if ((*(*l_element_courant).donnee).type != INT)
			{
				liberation(s_etat_processus, s_objet_argument);

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

			interruption = (*((integer8 *) (*(*l_element_courant)
					.donnee).objet));

			if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
			{
				liberation(s_etat_processus, s_objet_argument);

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

			(*s_etat_processus).masque_interruptions[interruption - 1] = 'I';
			l_element_courant = (*l_element_courant).suivant;
		}
	}
	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 'swistatus'
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_swistatus(struct_processus *s_etat_processus)
{
	int							i;

	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_futur;
	struct_liste_chainee		*l_element_liste;

	struct_objet				*s_objet_resultat;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(état des interruptions logicielles)\n\n");
		}
		else
		{
			printf("(software interrupts status)\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("    { { initialized interrupts }\n"
				"      { unlocked interrupts }\n"
				"      { queued interrupts }\n"
				"      { locked interrupts } }\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_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 = (struct_liste_chainee *) (*s_objet_resultat).objet;

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

	l_element_liste = NULL;
	l_element_futur = NULL;

	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
	{
		if ((*s_etat_processus).corps_interruptions[i] != NULL)
		{
			if (l_element_liste == NULL)
			{
				if ((l_element_liste =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_futur = l_element_liste;
			}
			else
			{
				if (((*l_element_liste).suivant =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_liste = (*l_element_liste).suivant;
			}

			(*l_element_liste).suivant = NULL;

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

			(*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
		}
	}

	(*(*l_element_courant).donnee).objet = l_element_futur;

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

	l_element_courant = (*l_element_courant).suivant;

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

	l_element_liste = NULL;
	l_element_futur = NULL;

	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
	{
		if ((*s_etat_processus).masque_interruptions[i] == 'N')
		{
			if (l_element_liste == NULL)
			{
				if ((l_element_liste =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_futur = l_element_liste;
			}
			else
			{
				if (((*l_element_liste).suivant =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_liste = (*l_element_liste).suivant;
			}

			(*l_element_liste).suivant = NULL;

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

			(*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
		}
	}

	(*(*l_element_courant).donnee).objet = l_element_futur;

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

	l_element_courant = (*l_element_courant).suivant;

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

	l_element_liste = NULL;
	l_element_futur = NULL;

	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
	{
		if ((*s_etat_processus).masque_interruptions[i] == 'Q')
		{
			if (l_element_liste == NULL)
			{
				if ((l_element_liste =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_futur = l_element_liste;
			}
			else
			{
				if (((*l_element_liste).suivant =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_liste = (*l_element_liste).suivant;
			}

			(*l_element_liste).suivant = NULL;

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

			(*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
		}
	}

	(*(*l_element_courant).donnee).objet = l_element_futur;

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

	l_element_courant = (*l_element_courant).suivant;

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

	l_element_liste = NULL;
	l_element_futur = NULL;

	for(i = 0; i < d_NOMBRE_INTERRUPTIONS; i++)
	{
		if ((*s_etat_processus).masque_interruptions[i] == 'I')
		{
			if (l_element_liste == NULL)
			{
				if ((l_element_liste =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_futur = l_element_liste;
			}
			else
			{
				if (((*l_element_liste).suivant =
						allocation_maillon(s_etat_processus)) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				l_element_liste = (*l_element_liste).suivant;
			}

			(*l_element_liste).suivant = NULL;

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

			(*((integer8 *) (*(*l_element_liste).donnee).objet)) = i + 1;
		}
	}

	(*(*l_element_courant).donnee).objet = l_element_futur;

	(*l_element_courant).suivant = NULL;

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

	return;
}


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

void
instruction_swiunlock(struct_processus *s_etat_processus)
{
	integer8					interruption;

	struct_liste_chainee		*l_element_courant;

	struct_objet				*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(déverrouillage des interruptions logicielles)\n\n");
		}
		else
		{
			printf("(software interrupt unlock)\n\n");
		}

		printf("    1: %s, %s\n", d_INT, 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, 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)
	{
		interruption = (*((integer8 *) (*s_objet_argument).objet));

		if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
		{
			liberation(s_etat_processus, s_objet_argument);

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

		(*s_etat_processus).masque_interruptions[interruption - 1] = 'N';
	}
	else if ((*s_objet_argument).type == LST)
	{
		l_element_courant = (*s_objet_argument).objet;

		while(l_element_courant)
		{
			if ((*(*l_element_courant).donnee).type != INT)
			{
				liberation(s_etat_processus, s_objet_argument);

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

			interruption = (*((integer8 *) (*(*l_element_courant)
					.donnee).objet));

			if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
			{
				liberation(s_etat_processus, s_objet_argument);

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

			(*s_etat_processus).masque_interruptions[interruption - 1] = 'N';
			l_element_courant = (*l_element_courant).suivant;
		}
	}
	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 'swiqueue'
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_swiqueue(struct_processus *s_etat_processus)
{
	integer8					interruption;

	struct_liste_chainee		*l_element_courant;

	struct_objet				*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(enregistre des interruptions logicielles)\n\n");
		}
		else
		{
			printf("(software interrupt record)\n\n");
		}

		printf("    1: %s, %s\n", d_INT, 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, 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)
	{
		interruption = (*((integer8 *) (*s_objet_argument).objet));

		if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
		{
			liberation(s_etat_processus, s_objet_argument);

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

		(*s_etat_processus).masque_interruptions[interruption - 1] = 'Q';
	}
	else if ((*s_objet_argument).type == LST)
	{
		l_element_courant = (*s_objet_argument).objet;

		while(l_element_courant)
		{
			if ((*(*l_element_courant).donnee).type != INT)
			{
				liberation(s_etat_processus, s_objet_argument);

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

			interruption = (*((integer8 *) (*(*l_element_courant)
					.donnee).objet));

			if ((interruption < 1) || (interruption > d_NOMBRE_INTERRUPTIONS))
			{
				liberation(s_etat_processus, s_objet_argument);

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

			(*s_etat_processus).masque_interruptions[interruption - 1] = 'Q';
			l_element_courant = (*l_element_courant).suivant;
		}
	}
	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 'sched'
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_sched(struct_processus *s_etat_processus)
{
	real8						pourcentage;

	struct_objet				*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(limitation des ressources de calcul)\n\n");
		}
		else
		{
			printf("(CPU ressources limitation)\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, 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)
	{
		pourcentage = (real8) (*((integer8 *) (*s_objet_argument).objet));
	}
	else if ((*s_objet_argument).type == REL)
	{
		pourcentage = (*((real8 *) (*s_objet_argument).objet));
	}
	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 ((pourcentage <= 0) || (pourcentage > 100))
	{
		(*s_etat_processus).erreur_execution = d_ex_argument_invalide;
		return;
	}

	(*s_etat_processus).pourcentage_maximal_cpu = pourcentage;

	return;
}

// vim: ts=4