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

void
instruction_egvl(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  EGVL ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(valeurs propres)\n\n");
		}
		else
		{
			printf("(eigenvalues)\n\n");
		}

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

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

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
		{
			return;
		}
	}

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

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

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

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

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

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

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

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

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

	else
	{
		liberation(s_etat_processus, s_objet_argument);

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

	liberation(s_etat_processus, s_objet_argument);

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

	return;
}


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

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

	(*s_etat_processus).erreur_execution = d_ex;

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

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

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

	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
		{
			return;
		}
	}

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

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

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

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

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

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

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

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

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

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

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

	else
	{
		liberation(s_etat_processus, s_objet_argument);

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

	liberation(s_etat_processus, s_objet_argument);

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

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

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

	return;
}


/*
================================================================================
  Fonction 'erase' (detruit la queue d'impression)
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(efface la file d'impression)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(erase the printer queue)\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).nom_fichier_impression != NULL)
	{
		if (destruction_fichier((*s_etat_processus).nom_fichier_impression)
				== d_erreur)
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}

		free((*s_etat_processus).nom_fichier_impression);
		(*s_etat_processus).nom_fichier_impression = NULL;
	}

	return;
}


/*
================================================================================
  Fonction 'epsilon' (renvoie la le plus petit réel e tel x + e != x)
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_epsilon(struct_processus *s_etat_processus)
{
	struct_objet			*s_copie;
	struct_objet			*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  EPSILON ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(epsilon machine)\n\n");
		}
		else
		{
			printf("(computer epsilon)\n\n");
		}

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

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

		printf("    1: %s\n", d_REL);
		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, 0) == 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_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	liberation(s_etat_processus, s_objet);
	s_objet = s_copie;

	/*
	 * L'argument est un entier et la routine renvoie 1.
	 */

	if ((*s_objet).type == INT)
	{
		(*((integer8 *) (*s_objet).objet)) = 1;
	}

	/*
	 * L'argument est un réel
	 */

	else if ((*s_objet).type == REL)
	{
		if ((*((real8 *) (*s_objet).objet)) == 0)
		{
			(*((real8 *) (*s_objet).objet)) = nextafter((double) 0, (double) 1);
		}
		else
		{
			(*((real8 *) (*s_objet).objet)) = nextafter(-abs(*((real8 *)
					(*s_objet).objet)), 0) + abs(*((real8 *) (*s_objet).objet));
		}
	}

	/*
	 * L'argument est un complexe
	 */

	else if ((*s_objet).type == CPL)
	{
		(*((complex16 *) (*s_objet).objet)).partie_reelle =
				nextafter(-abs((*((complex16 *) (*s_objet).objet))
				.partie_reelle), 0) + abs((*((complex16 *) (*s_objet).objet))
				.partie_reelle);
		(*((complex16 *) (*s_objet).objet)).partie_imaginaire =
				nextafter(-abs((*((complex16 *) (*s_objet).objet))
				.partie_imaginaire), 0) + abs((*((complex16 *)
				(*s_objet).objet)).partie_imaginaire);
	}
	else
	{
		liberation(s_etat_processus, s_objet);

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

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

	return;
}


/*
================================================================================
  Fonction 'errn' (detruit la queue d'impression)
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_errn(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  ERRN ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(numéro de la dernière erreur)\n\n");
		}
		else
		{
			printf("(last error number)\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, 0) == d_erreur)
		{
			return;
		}
	}

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

	if ((*s_etat_processus).derniere_exception != d_ep)
	{
		(*((integer8 *) (*s_objet_resultat).objet)) =
				1000 + ((*s_etat_processus).derniere_exception - d_ep);
	}
	else if ((*s_etat_processus).derniere_erreur_execution != d_ex)
	{
		(*((integer8 *) (*s_objet_resultat).objet)) =
				0 + ((*s_etat_processus).derniere_erreur_execution - d_ex);
	}
	else if ((*s_etat_processus).derniere_erreur_systeme != d_es)
	{
		/*
		 * On ne doit jamais passer par ici !
		 */

		(*((integer8 *) (*s_objet_resultat).objet)) =
				2000 + ((*s_etat_processus).derniere_erreur_systeme - d_es);
	}
	else
	{
		(*((integer8 *) (*s_objet_resultat).objet)) = 0;
	}
		
	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			s_objet_resultat) == d_erreur)
	{
		return;
	}

	return;
}


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

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

	int						registre_erreur_execution;
	int						registre_erreur_systeme;
	int						registre_exception;

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  ERRM ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(dernier message d'erreur)\n\n");
		}
		else
		{
			printf("(last error message)\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;
	}

	registre_exception = (*s_etat_processus).exception;
	registre_erreur_execution = (*s_etat_processus).erreur_execution;
	registre_erreur_systeme = (*s_etat_processus).erreur_systeme;

	(*s_etat_processus).exception =
			(*s_etat_processus).derniere_exception;
	(*s_etat_processus).erreur_execution =
			(*s_etat_processus).derniere_erreur_execution;
	(*s_etat_processus).erreur_systeme =
			(*s_etat_processus).derniere_erreur_systeme;

	if (((*s_objet_resultat).objet =
			messages(s_etat_processus)) == NULL)
	{
		(*s_etat_processus).exception =
				registre_exception;
		(*s_etat_processus).erreur_execution =
				registre_erreur_execution;
		(*s_etat_processus).erreur_systeme =
				registre_erreur_systeme;

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

	(*s_etat_processus).exception = registre_exception;
	(*s_etat_processus).erreur_execution = registre_erreur_execution;
	(*s_etat_processus).erreur_systeme = registre_erreur_systeme;

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

	return;
}


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

void
instruction_edit(struct_processus *s_etat_processus)
{
#	ifdef VIM_SUPPORT
#	include "vim-conv.h"

	file					*fichier;

	logical1				drapeau49;
	logical1				drapeau50;

	struct_liste_chainee	*registre_pile_last;

	struct_objet			*s_copie;
	struct_objet			*s_objet;
	struct_objet			*s_objet_nom;

	unsigned char			*chaine;
	unsigned char			*commande;
	unsigned char			*nom_fichier;
	unsigned char			registre;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(édition d'un objet)\n\n");
		}
		else
		{
			printf("(edit object)\n\n");
		}

		printf("    1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %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);
		printf("->  n: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %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);
		printf("    ...\n");
		printf("    1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %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);
		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 != INT) &&
			((*s_objet).type != REL) &&
			((*s_objet).type != CPL) &&
			((*s_objet).type != VIN) &&
			((*s_objet).type != VRL) &&
			((*s_objet).type != VCX) &&
			((*s_objet).type != MIN) &&
			((*s_objet).type != MRL) &&
			((*s_objet).type != MCX) &&
			((*s_objet).type != TBL) &&
			((*s_objet).type != BIN) &&
			((*s_objet).type != NOM) &&
			((*s_objet).type != CHN) &&
			((*s_objet).type != LST) &&
			((*s_objet).type != ALG) &&
			((*s_objet).type != RPN))
	{
		liberation(s_etat_processus, s_objet);

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

	if ((s_copie = copie_objet(s_etat_processus, s_objet, 'O')) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	liberation(s_etat_processus, s_objet);
	s_objet = s_copie;

	// Création d'un fichier temporaire à éditer

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

	drapeau49 = test_cfsf(s_etat_processus, 49);
	drapeau50 = test_cfsf(s_etat_processus, 50);

	cf(s_etat_processus, 49);
	cf(s_etat_processus, 50);

	// Ecriture de l'objet dans le fichier en mode STD et multiligne

	if ((fichier = fopen(nom_fichier, "w+")) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	registre = (*s_etat_processus).autorisation_conversion_chaine;
	(*s_etat_processus).autorisation_conversion_chaine = 'N';

	if ((chaine = formateur(s_etat_processus, 0, s_objet)) == NULL)
	{
		(*s_etat_processus).autorisation_conversion_chaine = registre;

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

	(*s_etat_processus).autorisation_conversion_chaine = registre;

	if ((*s_objet).type == CHN)
	{
		if (fprintf(fichier, "\"%s\"\n", chaine) != (int) (strlen(chaine) + 3))
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}
	else
	{
		if (fprintf(fichier, "%s\n", chaine) != (int) (strlen(chaine) + 1))
		{
			(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
			return;
		}
	}

	free(chaine);

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

	if ((commande = malloc((strlen(ds_vim_commande) + strlen(nom_fichier)
			- 1) * sizeof(unsigned char))) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	sprintf(commande, ds_vim_commande, nom_fichier);

	if (system(commande) != 0)
	{
		free(commande);

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

	free(commande);

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

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

	strcpy((unsigned char *) (*s_objet_nom).objet, nom_fichier);

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

	registre_pile_last = (*s_etat_processus).l_base_pile_last;
	(*s_etat_processus).l_base_pile_last = NULL;

	instruction_recall(s_etat_processus);

	if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
	{
		return;
	}

	(*s_etat_processus).l_base_pile_last = registre_pile_last;

	// Destruction du fichier temporaire

	if (destruction_fichier(nom_fichier) == d_erreur)
	{
		(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
		return;
	}

	free(nom_fichier);

	if (((*s_etat_processus).erreur_systeme != d_es) ||
			((*s_etat_processus).erreur_execution != d_ex) ||
			((*s_etat_processus).exception != d_ep))
	{
		liberation(s_etat_processus, s_objet);

		return;
	}

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

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

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

	if (drapeau49 == d_vrai)
	{
		sf(s_etat_processus, 49);
	}
	else
	{
		cf(s_etat_processus, 49);
	}

	if (drapeau50 == d_vrai)
	{
		sf(s_etat_processus, 50);
	}
	else
	{
		cf(s_etat_processus, 50);
	}

#	endif

	return;
}


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

void
instruction_externals(struct_processus *s_etat_processus)
{
	logical1				ambiguite;

	integer8				i;

	struct_liste_chainee	*l_element_courant;

	struct_objet			*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(liste des définitions externes)\n\n");
		}
		else
		{
			printf("(list of external definitions)\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 ((s_objet = allocation(s_etat_processus, LST)) == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*s_objet).objet = NULL;

	/*
	 * { "fonction" } si la fonction n'est pas ambiguë
	 * { "bibliotheque$fonction" } sinon.
	 */

	l_element_courant = NULL;

	for(i = 0; i < (*s_etat_processus).nombre_instructions_externes; i++)
	{
		if (l_element_courant == NULL)
		{
			if (((*s_objet).objet = allocation_maillon(s_etat_processus))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			l_element_courant = (*s_objet).objet;
		}
		else
		{
			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;
		}

		(*l_element_courant).suivant = NULL;

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

		ambiguite = d_faux;

		if (i > 0)
		{
			if (strcmp((*s_etat_processus).s_instructions_externes[i].nom,
					(*s_etat_processus).s_instructions_externes[i - 1].nom)
					== 0)
			{
				ambiguite = d_vrai;
			}
		}

		if (((i + 1) < (*s_etat_processus).nombre_instructions_externes) &&
				(ambiguite == d_faux))
		{
			if (strcmp((*s_etat_processus).s_instructions_externes[i].nom,
					(*s_etat_processus).s_instructions_externes[i + 1].nom)
					== 0)
			{
				ambiguite = d_vrai;
			}
		}

		if (ambiguite == d_faux)
		{
			if (((*(*l_element_courant).donnee).objet = malloc((strlen(
					(*s_etat_processus).s_instructions_externes[i].nom) + 1)
					* sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
					(*s_etat_processus).s_instructions_externes[i].nom);

			if ((*s_etat_processus).s_instructions_externes[i].position_fleche
					>= 0)
			{
				memcpy((unsigned char *) (*(*l_element_courant).donnee).objet
						+ (*s_etat_processus).s_instructions_externes[i]
						.position_fleche - (strlen((*s_etat_processus)
						.s_instructions_externes[i].nom_bibliotheque) + 1),
						"->", 2);
			}
		}
		else
		{
			if (((*(*l_element_courant).donnee).objet = malloc((strlen(
					(*s_etat_processus).s_instructions_externes[i].nom) +
					strlen((*s_etat_processus).s_instructions_externes[i]
					.nom_bibliotheque) + 2) * sizeof(unsigned char))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			sprintf((unsigned char *) (*(*l_element_courant).donnee).objet,
					"%s$%s", (*s_etat_processus).s_instructions_externes[i]
					.nom_bibliotheque, (*s_etat_processus)
					.s_instructions_externes[i].nom);

			if ((*s_etat_processus).s_instructions_externes[i].position_fleche
					>= 0)
			{
				memcpy((unsigned char *) (*(*l_element_courant).donnee).objet
						+ (*s_etat_processus).s_instructions_externes[i]
						.position_fleche, "->", 2);
			}
		}
	}

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

	return;
}


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

void
instruction_exit(struct_processus *s_etat_processus)
{
	logical1						drapeau_boucle_definie;
	logical1						drapeau_presence_fin_boucle;
	logical1						erreur;
	logical1						presence_boucle;
	logical1						presence_compteur;

	struct_liste_pile_systeme		*l_element_pile_systeme;

	unsigned char					*instruction_majuscule;
	unsigned char					*tampon;

	integer8						niveau;

	void							(*fonction)();

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(structure de contrôle)\n\n");
			printf("  Utilisation :\n\n");
		}
		else
		{
			printf("(control statement)\n\n");
			printf("  Usage:\n\n");
		}

		printf("    START/FOR\n");
		printf("        (expression 1)\n");
		printf("        EXIT\n");
		printf("        (expression 2)\n");
		printf("    NEXT/STEP\n\n");

		printf("    FORALL\n");
		printf("        (expression 1)\n");
		printf("        EXIT\n");
		printf("        (expression 2)\n");
		printf("    NEXT\n\n");

		printf("    DO\n");
		printf("        (expression 1)\n");
		printf("        EXIT\n");
		printf("        (expression 2)\n");
		printf("    UNTIL\n");
		printf("        (expression test 1)\n");
		printf("        [EXIT\n");
		printf("        (expression test 2)]\n");
		printf("    END\n\n");

		printf("    WHILE\n");
		printf("        (expression test 1)\n");
		printf("        [EXIT\n");
		printf("        (expression test 2)]\n");
		printf("    REPEAT\n");
		printf("        (expression 1)\n");
		printf("        EXIT\n");
		printf("        (expression 2)\n");
		printf("    END\n");

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

	/*
	 * Test de la présence de l'instruction EXIT dans une boucle
	 */

	l_element_pile_systeme = (*s_etat_processus).l_base_pile_systeme;
	presence_boucle = d_faux;
	drapeau_boucle_definie = d_faux;

	while((l_element_pile_systeme != NULL) && (presence_boucle == d_faux))
	{
		if (((*l_element_pile_systeme).type_cloture == 'S') ||
				((*l_element_pile_systeme).type_cloture == 'F') ||
				((*l_element_pile_systeme).type_cloture == 'A'))
		{
			presence_boucle = d_vrai;
			drapeau_boucle_definie = d_vrai;
		}
		else if (((*l_element_pile_systeme).type_cloture ==  'D') ||
				((*l_element_pile_systeme).type_cloture == 'W'))
		{
			presence_boucle = d_vrai;
			drapeau_boucle_definie = d_faux;
		}

		l_element_pile_systeme = (*l_element_pile_systeme).suivant;
	}

	if (presence_boucle == d_faux)
	{
		(*s_etat_processus).erreur_execution = d_ex_exit_hors_boucle;
		return;
	}

	if ((*s_etat_processus).mode_execution_programme == 'Y')
	{
		drapeau_presence_fin_boucle = d_vrai;
		tampon = (*s_etat_processus).instruction_courante;
		niveau = 1;

		instruction_majuscule = conversion_majuscule(s_etat_processus, "");

		if (drapeau_boucle_definie == d_vrai)
		{
			while(!(((strcmp(instruction_majuscule, "NEXT") == 0) ||
					(strcmp(instruction_majuscule, "STEP") == 0)) &&
					(niveau == 0)))
			{
				free(instruction_majuscule);

				erreur = recherche_instruction_suivante(s_etat_processus);

				if (erreur == d_erreur)
				{
					return;
				}

				(*s_etat_processus).erreur_systeme = d_es;
				instruction_majuscule = conversion_majuscule(s_etat_processus,
						(*s_etat_processus).instruction_courante);

				if (instruction_majuscule == NULL)
				{
					return;
				}

				/*
				 * Traitement de la pile système par les
				 * différentes instructions.
				 */

				if ((strcmp(instruction_majuscule, "IF") == 0) ||
						(strcmp(instruction_majuscule, "IFERR") == 0) ||
						(strcmp(instruction_majuscule, "DO") == 0) ||
						(strcmp(instruction_majuscule, "WHILE") == 0) ||
						(strcmp(instruction_majuscule, "FOR") == 0) ||
						(strcmp(instruction_majuscule, "FORALL") == 0) ||
						(strcmp(instruction_majuscule, "START") == 0) ||
						(strcmp(instruction_majuscule, "SELECT") == 0)
						|| (strcmp(instruction_majuscule, "CRITICAL") == 0)
						|| (strcmp(instruction_majuscule, "CASE") == 0)
						|| (strcmp(instruction_majuscule, "<<") == 0))
				{
					if (strcmp(instruction_majuscule, "<<") == 0)
					{
						analyse(s_etat_processus, NULL);
					}
					else
					{
						if ((strcmp(instruction_majuscule, "FOR") == 0) ||
								(strcmp(instruction_majuscule, "FORALL") == 0)
								|| (strcmp(instruction_majuscule, "START")
								== 0))
						{
							niveau++;
						}

						empilement_pile_systeme(s_etat_processus);

						if ((*s_etat_processus).erreur_systeme != d_es)
						{
							return;
						}
					}
				}
				else if ((strcmp(instruction_majuscule, "END") == 0) ||
						(strcmp(instruction_majuscule, "NEXT") == 0) ||
						(strcmp(instruction_majuscule, "STEP") == 0) ||
						(strcmp(instruction_majuscule, ">>") == 0))
				{
					if (strcmp(instruction_majuscule, ">>") == 0)
					{
						analyse(s_etat_processus, NULL);

						if ((*s_etat_processus).retour_routine_evaluation
								== 'Y')
						{
							drapeau_presence_fin_boucle = d_faux;
							free((*s_etat_processus).instruction_courante);

							break;
						}
					}
					else
					{
						if ((strcmp(instruction_majuscule, "NEXT") == 0) ||
								(strcmp(instruction_majuscule, "STEP")
								== 0))
						{
							niveau--;

							if (niveau != 0)
							{
								depilement_pile_systeme(s_etat_processus);
							}
						}
						else
						{
							if ((*s_etat_processus).l_base_pile_systeme == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_processus;
								return;
							}

							if ((*(*s_etat_processus).l_base_pile_systeme)
									.type_cloture == 'Q')
							{
								if (pthread_mutex_unlock(
										&mutex_sections_critiques) != 0)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_processus;
									return;
								}

								(*s_etat_processus).sections_critiques--;
							}

							depilement_pile_systeme(s_etat_processus);
						}

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

				free((*s_etat_processus).instruction_courante);
			}
		}
		else
		{
			while(!((strcmp(instruction_majuscule, "END") == 0) &&
					(niveau == 0)))
			{
				free(instruction_majuscule);

				erreur = recherche_instruction_suivante(s_etat_processus);

				if (erreur == d_erreur)
				{
					return;
				}

				instruction_majuscule = conversion_majuscule(s_etat_processus,
						(*s_etat_processus).instruction_courante);

				if (instruction_majuscule == NULL)
				{
					return;
				}

				/*
				 * Traitement de la pile système par les
				 * différentes instructions.
				 */

				if ((strcmp(instruction_majuscule, "IF") == 0) ||
						(strcmp(instruction_majuscule, "IFERR") == 0) ||
						(strcmp(instruction_majuscule, "DO") == 0) ||
						(strcmp(instruction_majuscule, "WHILE") == 0) ||
						(strcmp(instruction_majuscule, "FOR") == 0) ||
						(strcmp(instruction_majuscule, "FORALL") == 0) ||
						(strcmp(instruction_majuscule, "START") == 0) ||
						(strcmp(instruction_majuscule, "SELECT") == 0)
						|| (strcmp(instruction_majuscule, "CRITICAL") == 0)
						|| (strcmp(instruction_majuscule, "CASE") == 0)
						|| (strcmp(instruction_majuscule, "<<") == 0))
				{
					if (strcmp(instruction_majuscule, "<<") == 0)
					{
						analyse(s_etat_processus, NULL);
					}
					else
					{
						if ((strcmp(instruction_majuscule, "DO") == 0) ||
								(strcmp(instruction_majuscule, "WHILE")
								== 0))
						{
							niveau++;
						}

						empilement_pile_systeme(s_etat_processus);

						if ((*s_etat_processus).erreur_systeme != d_es)
						{
							return;
						}
					}
				}
				else if ((strcmp(instruction_majuscule, "END") == 0) ||
						(strcmp(instruction_majuscule, "NEXT") == 0) ||
						(strcmp(instruction_majuscule, "STEP") == 0) ||
						(strcmp(instruction_majuscule, ">>") == 0))
				{
					if (strcmp(instruction_majuscule, ">>") == 0)
					{
						analyse(s_etat_processus, NULL);

						if ((*s_etat_processus).retour_routine_evaluation
								== 'Y')
						{
							drapeau_presence_fin_boucle = d_faux;
							free((*s_etat_processus).instruction_courante);

							break;
						}
					}
					else
					{
						if (strcmp(instruction_majuscule, "END") == 0)
						{
							if (((*(*s_etat_processus).l_base_pile_systeme)
									.type_cloture == 'D') ||
									((*(*s_etat_processus)
									.l_base_pile_systeme).type_cloture
									== 'W'))
							{
								niveau--;
							}

							depilement_pile_systeme(s_etat_processus);
						}
						else
						{
							if ((*s_etat_processus).l_base_pile_systeme == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_processus;
								return;
							}

							if ((*(*s_etat_processus).l_base_pile_systeme)
									.type_cloture == 'Q')
							{
								if (pthread_mutex_unlock(
										&mutex_sections_critiques) != 0)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_processus;
									return;
								}

								(*s_etat_processus).sections_critiques--;
							}

							depilement_pile_systeme(s_etat_processus);
						}

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

				free((*s_etat_processus).instruction_courante);
			}
		}

		if (drapeau_presence_fin_boucle == d_faux)
		{
			(*s_etat_processus).traitement_cycle_exit = 'E';
		}
		else
		{
			(*s_etat_processus).traitement_cycle_exit = 'N';
		}

		free(instruction_majuscule);
		(*s_etat_processus).instruction_courante = tampon;
	}
	else
	{
		/* EXIT apparaissant dans l'évaluation d'une expression */

		drapeau_presence_fin_boucle = d_faux;
		instruction_majuscule = NULL;
		niveau = 1;

		if (drapeau_boucle_definie == d_vrai)
		{
			while((*s_etat_processus).expression_courante != NULL)
			{
				while((*(*(*s_etat_processus).expression_courante)
						.donnee).type != FCT)
				{
					if ((*s_etat_processus).expression_courante == NULL)
					{
						(*s_etat_processus).erreur_execution =
								d_ex_erreur_traitement_boucle;
						return;
					}

					(*s_etat_processus).expression_courante =
							(*(*s_etat_processus).expression_courante).suivant;
				}

				fonction = (*((struct_fonction *) (*(*(*s_etat_processus)
						.expression_courante).donnee).objet)).fonction;

				if ((fonction == instruction_if) ||
						(fonction == instruction_iferr) ||
						(fonction == instruction_do) ||
						(fonction == instruction_while) ||
						(fonction == instruction_for) ||
						(fonction == instruction_forall) ||
						(fonction == instruction_start) ||
						(fonction == instruction_select) ||
						(fonction == instruction_case) ||
						(fonction == instruction_critical) ||
						(fonction == instruction_vers_niveau_superieur))
				{
					if (fonction == instruction_vers_niveau_superieur)
					{
						analyse(s_etat_processus,
								instruction_vers_niveau_superieur);
					}
					else
					{
						if ((fonction == instruction_for) ||
								(fonction == instruction_forall) ||
								(fonction == instruction_start))
						{
							niveau++;
						}

						empilement_pile_systeme(s_etat_processus);

						if ((*s_etat_processus).erreur_systeme != d_es)
						{
							return;
						}
					}
				}
				else if ((fonction == instruction_end) ||
						(fonction == instruction_next) ||
						(fonction == instruction_step) ||
						(fonction == instruction_vers_niveau_inferieur))
				{
					if (fonction == instruction_vers_niveau_inferieur)
					{
						tampon = (*s_etat_processus).instruction_courante;
						(*s_etat_processus).instruction_courante =
								instruction_majuscule;

						analyse(s_etat_processus,
								instruction_vers_niveau_inferieur);

						(*s_etat_processus).instruction_courante = tampon;
					}
					else
					{
						if ((fonction == instruction_next) ||
								(fonction == instruction_step))
						{
							niveau--;

							if (niveau != 0)
							{
								depilement_pile_systeme(s_etat_processus);
							}
							else
							{
								drapeau_presence_fin_boucle = d_vrai;
								break;
							}
						}
						else
						{
							if ((*s_etat_processus).l_base_pile_systeme == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_processus;
								return;
							}

							if ((*(*s_etat_processus).l_base_pile_systeme)
									.type_cloture == 'Q')
							{
								if (pthread_mutex_unlock(
										&mutex_sections_critiques) != 0)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_processus;
									return;
								}

								(*s_etat_processus).sections_critiques--;
							}

							depilement_pile_systeme(s_etat_processus);
						}

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

				(*s_etat_processus).expression_courante = (*(*s_etat_processus)
						.expression_courante).suivant;
			}
		}
		else
		{
			while((*s_etat_processus).expression_courante != NULL)
			{
				while((*(*(*s_etat_processus).expression_courante)
						.donnee).type != FCT)
				{
					if ((*s_etat_processus).expression_courante == NULL)
					{
						(*s_etat_processus).erreur_execution =
								d_ex_erreur_traitement_boucle;
						return;
					}

					(*s_etat_processus).expression_courante =
							(*(*s_etat_processus).expression_courante).suivant;
				}

				fonction = (*((struct_fonction *) (*(*(*s_etat_processus)
						.expression_courante).donnee).objet)).fonction;

				if ((fonction == instruction_if) ||
						(fonction == instruction_iferr) ||
						(fonction == instruction_do) ||
						(fonction == instruction_while) ||
						(fonction == instruction_for) ||
						(fonction == instruction_forall) ||
						(fonction == instruction_start) ||
						(fonction == instruction_select) ||
						(fonction == instruction_critical) ||
						(fonction == instruction_case) ||
						(fonction == instruction_vers_niveau_superieur))
				{
					if (fonction == instruction_vers_niveau_superieur)
					{
						analyse(s_etat_processus,
								instruction_vers_niveau_superieur);
					}
					else
					{
						if ((fonction == instruction_do) ||
								(fonction == instruction_while))
						{
							niveau++;
						}

						empilement_pile_systeme(s_etat_processus);

						if ((*s_etat_processus).erreur_systeme != d_es)
						{
							return;
						}
					}
				}
				else if ((fonction == instruction_end) ||
						(fonction == instruction_next) ||
						(fonction == instruction_step) ||
						(fonction == instruction_vers_niveau_inferieur))
				{
					if (fonction == instruction_vers_niveau_inferieur)
					{
						analyse(s_etat_processus,
								instruction_vers_niveau_inferieur);
					}
					else
					{
						if (fonction == instruction_end)
						{
							if (((*(*s_etat_processus).l_base_pile_systeme)
									.type_cloture == 'D') ||
									((*(*s_etat_processus).l_base_pile_systeme)
									.type_cloture == 'W'))
							{
								niveau--;
							}

							depilement_pile_systeme(s_etat_processus);

							if (niveau == 0)
							{
								drapeau_presence_fin_boucle = d_vrai;
								break;
							}
						}
						else
						{
							if ((*s_etat_processus).l_base_pile_systeme == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_processus;
								return;
							}

							if ((*(*s_etat_processus).l_base_pile_systeme)
									.type_cloture == 'Q')
							{
								if (pthread_mutex_unlock(
										&mutex_sections_critiques) != 0)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_processus;
									return;
								}

								(*s_etat_processus).sections_critiques--;
							}

							depilement_pile_systeme(s_etat_processus);
						}

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

				(*s_etat_processus).expression_courante = (*(*s_etat_processus)
						.expression_courante).suivant;
			}
		}

		if (drapeau_presence_fin_boucle == d_faux)
		{
			(*s_etat_processus).traitement_cycle_exit = 'E';
		}
		else
		{
			(*s_etat_processus).traitement_cycle_exit = 'N';
		}
	}

	if ((drapeau_boucle_definie == d_vrai) &&
			(drapeau_presence_fin_boucle == d_vrai))
	{
		presence_compteur = (((*(*s_etat_processus).l_base_pile_systeme)
				.type_cloture == 'F') || ((*(*s_etat_processus)
				.l_base_pile_systeme).type_cloture == 'A')) ? d_vrai : d_faux;

		if (((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'S')
				&& (presence_compteur == d_faux))
		{
			(*s_etat_processus).erreur_execution =
					d_ex_erreur_traitement_boucle;
			return;
		}

		depilement_pile_systeme(s_etat_processus);

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

		if (presence_compteur == d_vrai)
		{
			(*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL;
			(*s_etat_processus).niveau_courant--;

			if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
			{
				return;
			}
		}
	}

	return;
}

// vim: ts=4