/*
================================================================================
  RPL/2 (R) version 4.1.0.prerelease.1
  Copyright (C) 1989-2011 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


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

void
instruction_eval(struct_processus *s_etat_processus)
{
	logical1						last_valide;

	struct_objet					*s_objet;
	struct_objet					*s_objet_simplifie;

	unsigned char					registre_type_evaluation;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

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

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

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

		cf(s_etat_processus, 31);
	}

	registre_type_evaluation = (test_cfsf(s_etat_processus, 35) == d_vrai)
			? 'E' : 'N';
	sf(s_etat_processus, 35);

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet) == d_erreur)
	{
		if (last_valide == d_vrai)
		{
			sf(s_etat_processus, 31);
		}

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

	if ((s_objet_simplifie = simplification(s_etat_processus, s_objet)) == NULL)
	{
		if (last_valide == d_vrai)
		{
			sf(s_etat_processus, 31);
		}

		return;
	}

	liberation(s_etat_processus, s_objet);
	s_objet = s_objet_simplifie;

	if ((*s_etat_processus).l_base_pile_systeme == NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_pile_vide;
		return;
	}

	(*(*s_etat_processus).l_base_pile_systeme).evaluation_expression = d_vrai;

	if (evaluation(s_etat_processus, s_objet, 'E') == d_erreur)
	{
		(*(*s_etat_processus).l_base_pile_systeme)
				.evaluation_expression = d_faux;

		if (last_valide == d_vrai)
		{
			sf(s_etat_processus, 31);
		}

		liberation(s_etat_processus, s_objet);
		return;
	}

	(*(*s_etat_processus).l_base_pile_systeme).evaluation_expression = d_faux;
	liberation(s_etat_processus, s_objet);

	if (registre_type_evaluation == 'E')
	{
		sf(s_etat_processus, 35);
	}
	else
	{
		cf(s_etat_processus, 35);
	}

	if (last_valide == d_vrai)
	{
		sf(s_etat_processus, 31);
	}

	return;
}


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

void
instruction_end(struct_processus *s_etat_processus)
{
	logical1						condition;

	struct_liste_pile_systeme		*l_element_courant;

	struct_objet					*s_objet;

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

		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("    IF\n");
		printf("        (expression test 1)\n");
		printf("    THEN\n");
		printf("        (expression 1)\n");
		printf("    [ELSEIF\n");
		printf("        (expression test 2)\n");
		printf("    THEN\n");
		printf("        (expression 2)]\n");
		printf("    ...\n");
		printf("    [ELSE\n");
		printf("        (expression n)]\n");
		printf("    END\n\n");

		printf("    IFERR\n");
		printf("        (expression test)\n");
		printf("    THEN\n");
		printf("        (expression 1)\n");
		printf("    [ELSE\n");
		printf("        (expression 2)]\n");
		printf("    END\n\n");

		printf("    DO\n");
		printf("        (expression)\n");
		printf("    UNTIL\n");
		printf("        (expression test)\n");
		printf("    END\n\n");

		printf("    WHILE\n");
		printf("        (expression test)\n");
		printf("    REPEAT\n");
		printf("        (expression)\n");
		printf("    END\n\n");

		printf("    SELECT (expression test)\n");
		printf("        CASE (clause 1) THEN (expression 1) END\n");
		printf("        CASE (clause 2) THEN (expression 2) END\n");
		printf("        ...\n");
		printf("        CASE (clause n) THEN (expression n) END\n");
		printf("    DEFAULT\n");
		printf("        (expression)\n");
		printf("    END\n\n");

		printf("    SELECT (expression test)\n");
		printf("        CASE (clause 1) THEN (expression 1) END\n");
		printf("        (expression)\n");
		printf("        CASE (clause 2) THEN (expression 2) END\n");
		printf("    END\n");

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

	if (((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'I')
			|| ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'J'))
	{
		depilement_pile_systeme(s_etat_processus);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}
	}
	else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'D')
	{
		if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'U')
		{
			(*s_etat_processus).erreur_execution =
					d_ex_erreur_traitement_boucle;
			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))
		{
			if ((*s_objet).type == INT)
			{
				condition = ((*((integer8 *) (*s_objet).objet)) == 0)
						? d_faux : d_vrai;
			}
			else
			{
				condition = ((*((real8 *) (*s_objet).objet)) == 0)
						? d_faux : d_vrai;
			}

			if (condition == d_faux)
			{
				if ((*s_etat_processus).mode_execution_programme == 'Y')
				{
					(*s_etat_processus).position_courante =
							(*(*s_etat_processus).l_base_pile_systeme)
							.adresse_retour;
				}
				else
				{
					(*s_etat_processus).expression_courante =
							(*(*s_etat_processus).l_base_pile_systeme)
							.pointeur_objet_retour;
				}
			}
			else
			{
				depilement_pile_systeme(s_etat_processus);

				if ((*s_etat_processus).erreur_systeme != d_es)
				{
					return;
				}
			}
		}
		else
		{
			liberation(s_etat_processus, s_objet);

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

		liberation(s_etat_processus, s_objet);
	}
	else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'W')
	{
		if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'W')
		{
			if ((*s_etat_processus).mode_execution_programme == 'Y')
			{
				(*s_etat_processus).position_courante =
						(*(*s_etat_processus).l_base_pile_systeme)
						.adresse_retour;
			}
			else
			{
				(*s_etat_processus).expression_courante =
						(*(*s_etat_processus).l_base_pile_systeme)
						.pointeur_objet_retour;
			}
		}
		else
		{
			depilement_pile_systeme(s_etat_processus);

			if ((*s_etat_processus).erreur_systeme != d_es)
			{
				return;
			}
		}
	}
	else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'C')
	{
		depilement_pile_systeme(s_etat_processus);

		if ((*s_etat_processus).erreur_systeme != d_es)
		{
			return;
		}
	}
	else if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture == 'K')
	{
		l_element_courant = (*(*s_etat_processus).l_base_pile_systeme).suivant;

		while(l_element_courant != NULL)
		{
			switch((*l_element_courant).clause)
			{
				case 'K' :
				case 'Q' :
				case 'C' :
				{
					if ((*l_element_courant).clause == 'Q')
					{
						(*l_element_courant).clause = 'C';
					}
					else
					{
						(*l_element_courant).clause = (*(*s_etat_processus)
								.l_base_pile_systeme).clause;
					}

					l_element_courant = NULL;
					break;
				}

				default :
				{
					l_element_courant = (*l_element_courant).suivant;
					break;
				}
			}
		}

		depilement_pile_systeme(s_etat_processus);

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

	return;
}


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

void
instruction_else(struct_processus *s_etat_processus)
{
	logical1					drapeau_fin;
	logical1					execution;

	struct_liste_chainee		*s_registre;

	unsigned char				*instruction_majuscule;
	unsigned char				*tampon;

	unsigned long				niveau;

	void						(*fonction)();

	(*s_etat_processus).erreur_execution = d_ex;

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

		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("    IF\n");
		printf("        (expression test 1)\n");
		printf("    THEN\n");
		printf("        (expression 1)\n");
		printf("    [ELSEIF\n");
		printf("        (expression test 2)\n");
		printf("    THEN\n");
		printf("        (expression 2)]\n");
		printf("    ...\n");
		printf("    ELSE\n");
		printf("        (expression n)\n");
		printf("    END\n");

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

	if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'T')
	{
		niveau = 0;
		drapeau_fin = d_faux;

		if ((*s_etat_processus).mode_execution_programme == 'Y')
		{
			tampon = (*s_etat_processus).instruction_courante;

			do
			{
				if (recherche_instruction_suivante(s_etat_processus)
						== d_erreur)
				{
					if ((*s_etat_processus).instruction_courante != NULL)
					{
						free((*s_etat_processus).instruction_courante);
					}

					(*s_etat_processus).instruction_courante = tampon;
					(*s_etat_processus).erreur_execution =
							d_ex_erreur_traitement_condition;
					return;
				}

				if ((instruction_majuscule = conversion_majuscule(
						(*s_etat_processus).instruction_courante)) == NULL)
				{
					free((*s_etat_processus).instruction_courante);
					(*s_etat_processus).instruction_courante = tampon;
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (niveau == 0)
				{
					if (strcmp(instruction_majuscule, "END") == 0)
					{
						(*s_etat_processus).position_courante -= (strlen(
								instruction_majuscule) + 1);
						drapeau_fin = d_vrai;
					}
					else
					{
						drapeau_fin = d_faux;
					}
				}
				else
				{
					drapeau_fin = d_faux;
				}

				if ((strcmp(instruction_majuscule, "CASE") == 0) ||
						(strcmp(instruction_majuscule, "DO") == 0) ||
						(strcmp(instruction_majuscule, "IF") == 0) ||
						(strcmp(instruction_majuscule, "IFERR") == 0) ||
						(strcmp(instruction_majuscule, "SELECT") == 0) ||
						(strcmp(instruction_majuscule, "WHILE") == 0))
				{
					niveau++;
				}
				else if (strcmp(instruction_majuscule, "END") == 0)
				{
					niveau--;
				}

				free(instruction_majuscule);
				free((*s_etat_processus).instruction_courante);
			} while(drapeau_fin == d_faux);

			(*s_etat_processus).instruction_courante = tampon;
		}
		else
		{
			/*
			 * Vérification du pointeur de prédiction de saut.
			 */

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

			if ((*((struct_fonction *) (*(*(*s_etat_processus)
					.expression_courante).donnee).objet)).prediction_saut
					!= NULL)
			{
				s_registre = (*s_etat_processus).expression_courante;

				(*s_etat_processus).expression_courante =
						(struct_liste_chainee *)
						(*((struct_fonction *) (*(*(*s_etat_processus)
						.expression_courante).donnee).objet))
						.prediction_saut;
				fonction = (*((struct_fonction *)
						(*(*(*s_etat_processus).expression_courante)
						.donnee).objet)).fonction;
				execution = (*((struct_fonction *)
						(*(*s_registre).donnee).objet)).prediction_execution;

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

				if (execution == d_vrai)
				{
					fonction(s_etat_processus);
				}
			}
			else
			{
				if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
						.expression_courante).donnee).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				s_registre = (*s_etat_processus).expression_courante;
				execution = d_faux;

				do
				{
					if (((*s_etat_processus).expression_courante =
							(*(*s_etat_processus).expression_courante).suivant)
							== NULL)
					{
						(*s_etat_processus).erreur_execution =
								d_ex_erreur_traitement_condition;
						return;
					}

					if ((*(*(*s_etat_processus).expression_courante)
							.donnee).type == FCT)
					{
						fonction = (*((struct_fonction *)
								(*(*(*s_etat_processus).expression_courante)
								.donnee).objet)).fonction;

						if (niveau == 0)
						{
							if (fonction == instruction_end)
							{
								fonction(s_etat_processus);
								execution = d_vrai;
								drapeau_fin = d_vrai;
							}
							else
							{
								drapeau_fin = d_faux;
							}
						}
						else
						{
							drapeau_fin = d_faux;
						}

						if ((fonction == instruction_case) ||
								(fonction == instruction_do) ||
								(fonction == instruction_if) ||
								(fonction == instruction_iferr) ||
								(fonction == instruction_select) ||
								(fonction == instruction_while))
						{
							niveau++;
						}
						else if (fonction == instruction_end)
						{
							niveau--;
						}
					}
				} while(drapeau_fin == d_faux);

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

				(*((struct_fonction *) (*(*s_registre).donnee).objet))
						.prediction_saut = (*s_etat_processus)
						.expression_courante;
				(*((struct_fonction *) (*(*s_registre).donnee).objet))
						.prediction_execution = execution;

				if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
						.expression_courante).donnee).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}
	}
	else if ((*(*s_etat_processus).l_base_pile_systeme).clause != 'E')
	{
		(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_condition;
		return;
	}
	else
	{
		(*(*s_etat_processus).l_base_pile_systeme).clause = 'Z';
	}

	return;
}


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

void
instruction_elseif(struct_processus *s_etat_processus)
{
	logical1					drapeau_fin;
	logical1					execution;

	struct_liste_chainee		*s_registre;

	unsigned char				*instruction_majuscule;
	unsigned char				*tampon;

	unsigned long				niveau;

	void						(*fonction)();

	(*s_etat_processus).erreur_execution = d_ex;

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

		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("    IF\n");
		printf("        (expression test 1)\n");
		printf("    THEN\n");
		printf("        (expression 1)\n");
		printf("    ELSEIF\n");
		printf("        (expression test 2)\n");
		printf("    THEN\n");
		printf("        (expression 2)\n");
		printf("    ...\n");
		printf("    [ELSE\n");
		printf("        (expression n)]\n");
		printf("    END\n\n");

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

	if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'I')
	{
		(*s_etat_processus).erreur_execution =
				d_ex_erreur_traitement_condition;
		return;
	}
		
	if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'T')
	{
		/*
		 * On saute au END car le test précédent était vrai.
		 */

		niveau = 0;
		drapeau_fin = d_faux;

		if ((*s_etat_processus).mode_execution_programme == 'Y')
		{
			tampon = (*s_etat_processus).instruction_courante;

			do
			{
				if (recherche_instruction_suivante(s_etat_processus)
						== d_erreur)
				{
					if ((*s_etat_processus).instruction_courante != NULL)
					{
						free((*s_etat_processus).instruction_courante);
					}

					(*s_etat_processus).instruction_courante = tampon;
					(*s_etat_processus).erreur_execution =
							d_ex_erreur_traitement_condition;
					return;
				}

				if ((instruction_majuscule = conversion_majuscule(
						(*s_etat_processus).instruction_courante)) == NULL)
				{
					free((*s_etat_processus).instruction_courante);
					(*s_etat_processus).instruction_courante = tampon;
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				if (niveau == 0)
				{
					if (strcmp(instruction_majuscule, "END") == 0)
					{
						(*s_etat_processus).position_courante -= (strlen(
								instruction_majuscule) + 1);
						drapeau_fin = d_vrai;
					}
					else
					{
						drapeau_fin = d_faux;
					}
				}
				else
				{
					drapeau_fin = d_faux;
				}

				if ((strcmp(instruction_majuscule, "CASE") == 0) ||
						(strcmp(instruction_majuscule, "DO") == 0) ||
						(strcmp(instruction_majuscule, "IF") == 0) ||
						(strcmp(instruction_majuscule, "IFERR") == 0) ||
						(strcmp(instruction_majuscule, "SELECT") == 0) ||
						(strcmp(instruction_majuscule, "WHILE") == 0))
				{
					niveau++;
				}
				else if (strcmp(instruction_majuscule, "END") == 0)
				{
					niveau--;
				}

				free(instruction_majuscule);
				free((*s_etat_processus).instruction_courante);
			} while(drapeau_fin == d_faux);

			(*s_etat_processus).instruction_courante = tampon;
		}
		else
		{
			/*
			 * Vérification du pointeur de prédiction de saut
			 */

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

			if ((*((struct_fonction *) (*(*(*s_etat_processus)
					.expression_courante).donnee).objet)).prediction_saut
					!= NULL)
			{
				s_registre = (*s_etat_processus).expression_courante;

				(*s_etat_processus).expression_courante =
						(struct_liste_chainee *)
						(*((struct_fonction *) (*(*(*s_etat_processus)
						.expression_courante).donnee).objet))
						.prediction_saut;
				fonction = (*((struct_fonction *)
						(*(*(*s_etat_processus).expression_courante)
						.donnee).objet)).fonction;
				execution = (*((struct_fonction *)
						(*(*s_registre).donnee).objet)).prediction_execution;

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

				if (execution == d_vrai)
				{
					fonction(s_etat_processus);
				}
			}
			else
			{
				if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
						.expression_courante).donnee).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}

				s_registre = (*s_etat_processus).expression_courante;
				execution = d_faux;

				do
				{
					if (((*s_etat_processus).expression_courante =
							(*(*s_etat_processus).expression_courante).suivant)
							== NULL)
					{
						(*s_etat_processus).erreur_execution =
								d_ex_erreur_traitement_condition;
						return;
					}

					if ((*(*(*s_etat_processus).expression_courante)
							.donnee).type == FCT)
					{
						fonction = (*((struct_fonction *)
								(*(*(*s_etat_processus).expression_courante)
								.donnee).objet)).fonction;

						if (niveau == 0)
						{
							if (fonction == instruction_end)
							{
								instruction_end(s_etat_processus);
								execution = d_vrai;
								drapeau_fin = d_vrai;
							}
							else
							{
								drapeau_fin = d_faux;
							}
						}
						else
						{
							drapeau_fin = d_faux;
						}

						if ((fonction == instruction_case) ||
								(fonction == instruction_do) ||
								(fonction == instruction_if) ||
								(fonction == instruction_iferr) ||
								(fonction == instruction_select) ||
								(fonction == instruction_while))
						{
							niveau++;
						}
						else if (fonction == instruction_end)
						{
							niveau--;
						}
					}
				} while(drapeau_fin == d_faux);

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

				(*((struct_fonction *) (*(*s_registre).donnee).objet))
						.prediction_saut = (*s_etat_processus)
						.expression_courante;
				(*((struct_fonction *) (*(*s_registre).donnee).objet))
						.prediction_execution = execution;

				if (pthread_mutex_unlock(&((*(*(*s_etat_processus)
						.expression_courante).donnee).mutex)) != 0)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}
		}
	}
	else
	{
		/*
		 * On teste à nouveau...
		 */

		(*(*s_etat_processus).l_base_pile_systeme).clause = 'I';
	}

	return;
}


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

void
instruction_sensible_e(struct_processus *s_etat_processus)
{
	if (strcmp((*s_etat_processus).instruction_courante, "e") == 0)
	{
		instruction_e(s_etat_processus);
	}
	else
	{
		(*s_etat_processus).instruction_valide = 'N';
	}

	return;
}

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

	(*s_etat_processus).erreur_execution = d_ex;

	if ((*s_etat_processus).affichage_arguments == 'Y')
	{
		printf("\n  e ");
		
		if ((*s_etat_processus).langue == 'F')
		{
			printf("(base de logarithmes népériens)\n\n");
		}
		else
		{
			printf("(base of natural logarithm)\n\n");
		}

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

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

	/* Indicateur 35 armé => évaluation symbolique */
	if (test_cfsf(s_etat_processus, 35) == d_vrai)
	{
		if ((s_objet = allocation(s_etat_processus, NOM)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_nom *) (*s_objet).objet)).nom =
				malloc(2 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_nom *) (*s_objet).objet)).nom, "e");
		(*((struct_nom *) (*s_objet).objet)).symbole = d_faux;
	}
	else
	{
		if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*s_objet).objet)) = exp((real8) 1);
	}

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

	return;
}


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

void
instruction_eng(struct_processus *s_etat_processus)
{
	struct_objet						*s_objet_argument;
	struct_objet						*s_objet;

	logical1							i43;
	logical1							i44;

	unsigned char						*valeur_binaire;

	unsigned long						i;
	unsigned long						j;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(notation ingénieur)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(engineer notation)\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, 1) == d_erreur)
		{
			return;
		}
	}

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

	if ((*s_objet_argument).type == INT)
	{
		if (((*((integer8 *) (*s_objet_argument).objet)) >= 0) &&
				((*((integer8 *) (*s_objet_argument).objet)) <= 15))
		{
			if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((logical8 *) (*s_objet).objet)) =
					(*((integer8 *) (*s_objet_argument).objet));

			i43 = test_cfsf(s_etat_processus, 43);
			i44 = test_cfsf(s_etat_processus, 44);

			sf(s_etat_processus, 44);
			cf(s_etat_processus, 43);

			if ((valeur_binaire = formateur(s_etat_processus, 0, s_objet))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			if (i43 == d_vrai)
			{
				sf(s_etat_processus, 43);
			}
			else
			{
				cf(s_etat_processus, 43);
			}

			if (i44 == d_vrai)
			{
				sf(s_etat_processus, 44);
			}
			else
			{
				cf(s_etat_processus, 44);
			}

			for(j = 53, i = strlen(valeur_binaire) - 2; i >= 2; i--)
			{
				if (valeur_binaire[i] == '0')
				{
					cf(s_etat_processus, j++);
				}
				else
				{
					sf(s_etat_processus, j++);
				}
			}

			for(; j <= 56; cf(s_etat_processus, j++));

			sf(s_etat_processus, 49);
			sf(s_etat_processus, 50);

			free(valeur_binaire);
			liberation(s_etat_processus, s_objet);
		}
		else
		{
			liberation(s_etat_processus, s_objet_argument);

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

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

	liberation(s_etat_processus, s_objet_argument);

	return;
}


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

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

	struct_objet					*s_copie_argument;
	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  EXP ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(exponentielle)\n\n");
		}
		else
		{
			printf("(exponential)\n\n");
		}

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

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

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

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

/*
--------------------------------------------------------------------------------
  Exponentielle d'un entier
--------------------------------------------------------------------------------
*/

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

		(*((real8 *) (*s_objet_resultat).objet)) =
				exp((real8) (*((integer8 *) (*s_objet_argument).objet)));
	}

/*
--------------------------------------------------------------------------------
  Exponentielle d'un réel
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_argument).type == REL)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*s_objet_resultat).objet)) =
				exp(((*((real8 *) (*s_objet_argument).objet))));
	}

/*
--------------------------------------------------------------------------------
  Exponentielle d'un complexe
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_argument).type == CPL)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		f77expc_((struct_complexe16 *) (*s_objet_argument).objet,
				(struct_complexe16 *) (*s_objet_resultat).objet);
	}

/*
--------------------------------------------------------------------------------
  Exponentielle d'un nom
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_argument).type == NOM)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == 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 = (*s_objet_resultat).objet;

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

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 0;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_vers_niveau_superieur;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, "<<");

		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).donnee = s_objet_argument;

		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, FCT))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 1;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_exp;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
			
		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, "EXP");

		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, FCT))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 0;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_vers_niveau_inferieur;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, ">>");

		(*l_element_courant).suivant = NULL;
		s_objet_argument = NULL;
	}

/*
--------------------------------------------------------------------------------
  Exponentielle d'une expression
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_argument).type == ALG) ||
			((*s_objet_argument).type == RPN))
	{
		if ((s_copie_argument = copie_objet(s_etat_processus,
				s_objet_argument, 'N')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_copie_argument).objet;
		l_element_precedent = l_element_courant;

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

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

		if (((*(*l_element_precedent).suivant).donnee =
				allocation(s_etat_processus, FCT)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
				.donnee).objet)).nombre_arguments = 1;
		(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
				.donnee).objet)).fonction = instruction_exp;

		if (((*((struct_fonction *) (*(*(*l_element_precedent)
				.suivant).donnee).objet)).nom_fonction =
				malloc(4 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
				.suivant).donnee).objet)).nom_fonction, "EXP");

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

		s_objet_resultat = s_copie_argument;
	}

/*
--------------------------------------------------------------------------------
  Fonction exponentielle impossible à réaliser
--------------------------------------------------------------------------------
*/

	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 'exp' (-1)
================================================================================
  Entrées : pointeur sur une struct_processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

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

	struct_objet					*s_copie_argument;
	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  EXPM ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(exponentielle moins un)\n\n");
		}
		else
		{
			printf("(exp - 1)\n\n");
		}

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

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

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

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

/*
--------------------------------------------------------------------------------
  Exponentielle (-1) d'un entier
--------------------------------------------------------------------------------
*/

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

		(*((real8 *) (*s_objet_resultat).objet)) =
				expm1((real8) (*((integer8 *) (*s_objet_argument).objet)));
	}

/*
--------------------------------------------------------------------------------
  Exponentielle (-1) d'un réel
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_argument).type == REL)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((real8 *) (*s_objet_resultat).objet)) =
				expm1(((*((real8 *) (*s_objet_argument).objet))));
	}

/*
--------------------------------------------------------------------------------
  Exponentielle (-1) d'un nom
--------------------------------------------------------------------------------
*/

	else if ((*s_objet_argument).type == NOM)
	{
		if ((s_objet_resultat = allocation(s_etat_processus, ALG)) == 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 = (*s_objet_resultat).objet;

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

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 0;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_vers_niveau_superieur;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, "<<");

		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).donnee = s_objet_argument;

		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, FCT))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 1;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_expm;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(5 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
			
		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, "EXPM");

		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, FCT))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nombre_arguments = 0;
		(*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.fonction = instruction_vers_niveau_inferieur;

		if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
				.nom_fonction, ">>");

		(*l_element_courant).suivant = NULL;
		s_objet_argument = NULL;
	}

/*
--------------------------------------------------------------------------------
  Exponentielle (-1) d'une expression
--------------------------------------------------------------------------------
*/

	else if (((*s_objet_argument).type == ALG) ||
			((*s_objet_argument).type == RPN))
	{
		if ((s_copie_argument = copie_objet(s_etat_processus,
				s_objet_argument, 'N')) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		l_element_courant = (struct_liste_chainee *)
				(*s_copie_argument).objet;
		l_element_precedent = l_element_courant;

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

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

		if (((*(*l_element_precedent).suivant).donnee =
				allocation(s_etat_processus, FCT)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
				.donnee).objet)).nombre_arguments = 1;
		(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
				.donnee).objet)).fonction = instruction_expm;

		if (((*((struct_fonction *) (*(*(*l_element_precedent)
				.suivant).donnee).objet)).nom_fonction =
				malloc(5 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		strcpy((*((struct_fonction *) (*(*(*l_element_precedent)
				.suivant).donnee).objet)).nom_fonction, "EXPM");

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

		s_objet_resultat = s_copie_argument;
	}

/*
--------------------------------------------------------------------------------
  Fonction exponentielle (-1) impossible à réaliser
--------------------------------------------------------------------------------
*/

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

// vim: ts=4