/*
================================================================================
  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 'clusr'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_clusr(struct_processus *s_etat_processus)
{
	struct_liste_variables				*l_element_courant;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(effacement des variables)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(clear variables)\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;
		}
	}

	l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;

	if (l_element_courant == NULL)
	{
		return;
	}

	do
	{
		if ((*l_element_courant).liste != NULL)
		{
			if ((*(*l_element_courant).liste).donnee != NULL)
			{
				if ((*((struct_variable *) (*(*l_element_courant).liste)
						.donnee)).niveau == 1)
				{
					while((*l_element_courant).liste != NULL)
					{
						if (retrait_variable(s_etat_processus,
								(*((struct_variable *) (*(*l_element_courant)
								.liste).donnee)).nom, 'G') == d_erreur)
						{
							return;
						}

						if ((*s_etat_processus).niveau_supprime == d_vrai)
						{
							// La dernière variable de niveau 1 a été
							// supprimée. On sort donc de la boucle car
							// (*l_element_courant).liste pointe sur
							// un pointeur libérée par retrait_variable().

							break;
						}
					}

					break;
				}
			}
		}

		l_element_courant = (*l_element_courant).precedent;
	} while(l_element_courant != (*s_etat_processus)
			.l_liste_variables_par_niveau);

	return;
}


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

void
instruction_col_fleche(struct_processus *s_etat_processus)
{
	struct_objet				*s_objet;
	struct_objet				*s_objet_elementaire;

	integer8					i;
	integer8					j;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(extraction des colonnes d'une matrice)\n\n");
		}
		else
		{
			printf("(extract matrix columns)\n\n");
		}

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

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

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

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

	if ((*s_objet).type == MIN)
	{
		for(i = 0; i < (*((struct_matrice *)
				(*s_objet).objet)).nombre_colonnes; i++)
		{
			if ((s_objet_elementaire = allocation(s_etat_processus, MIN))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_matrice *) (*s_objet_elementaire).objet))
					.nombre_colonnes = 1;
			(*((struct_matrice *) (*s_objet_elementaire).objet))
					.nombre_lignes = (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes;

			if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
					malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes) * sizeof(integer8 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes; j++)
			{
				if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
						.objet)).tableau)[j] = malloc(sizeof(integer8)))
						== NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
						.objet)).tableau)[j][0] = ((integer8 **)
						(*((struct_matrice *) (*s_objet).objet)).tableau)[j][i];
			}

			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					s_objet_elementaire) == d_erreur)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}
	}
	else if ((*s_objet).type == MRL)
	{
		for(i = 0; i < (*((struct_matrice *)
				(*s_objet).objet)).nombre_colonnes; i++)
		{
			if ((s_objet_elementaire = allocation(s_etat_processus, MRL))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_matrice *) (*s_objet_elementaire).objet))
					.nombre_colonnes = 1;
			(*((struct_matrice *) (*s_objet_elementaire).objet))
					.nombre_lignes = (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes;

			if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
					malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes) * sizeof(real8 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes; j++)
			{
				if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
						.objet)).tableau)[j] = malloc(sizeof(real8)))
						== NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
						.objet)).tableau)[j][0] = ((real8 **)
						(*((struct_matrice *) (*s_objet).objet)).tableau)[j][i];
			}

			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					s_objet_elementaire) == d_erreur)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
		}
	}
	else if ((*s_objet).type == MCX)
	{
		for(i = 0; i < (*((struct_matrice *)
				(*s_objet).objet)).nombre_colonnes; i++)
		{
			if ((s_objet_elementaire = allocation(s_etat_processus, MCX))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_matrice *) (*s_objet_elementaire).objet))
					.nombre_colonnes = 1;
			(*((struct_matrice *) (*s_objet_elementaire).objet))
					.nombre_lignes = (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes;

			if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
					malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes) * sizeof(complex16 *))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
					.nombre_lignes; j++)
			{
				if ((((complex16 **) (*((struct_matrice *)
						(*s_objet_elementaire).objet)).tableau)[j] =
						malloc(sizeof(complex16))) == NULL)
				{
					(*s_etat_processus).erreur_systeme =
							d_es_allocation_memoire;
					return;
				}

				(((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
						.objet)).tableau)[j][0]).partie_reelle =
						(((complex16 **) (*((struct_matrice *) (*s_objet)
						.objet)).tableau)[j][i]).partie_reelle;
				(((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
						.objet)).tableau)[j][0]).partie_imaginaire =
						(((complex16 **) (*((struct_matrice *) (*s_objet)
						.objet)).tableau)[j][i]).partie_imaginaire;
			}

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

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

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

	(*((integer8 *) (*s_objet_elementaire).objet)) =
			(*((struct_matrice *) (*s_objet).objet)).nombre_colonnes;

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

	liberation(s_etat_processus, s_objet);

	return;
}


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

void
instruction_clrswi(struct_processus *s_etat_processus)
{
	integer8						interruption;

	struct_objet					*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

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

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

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

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

	if ((*s_objet_argument).type == INT)
	{
		interruption = (*((integer8 *) (*s_objet_argument).objet));

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

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

		liberation(s_etat_processus, (*s_etat_processus)
				.corps_interruptions[interruption - 1]);
		(*s_etat_processus).corps_interruptions[interruption - 1] = NULL;
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument);

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

	return;
}


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

void
instruction_clrcntxt(struct_processus *s_etat_processus)
{
	struct_liste_chainee				*l_element_courant;
	struct_liste_chainee				*l_element_suivant;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(effacement des contextes)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(clear contexts)\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;
		}
	}

	l_element_courant = (*s_etat_processus).l_base_pile_contextes;

	while(l_element_courant != NULL)
	{
		l_element_suivant = (*l_element_courant).suivant;
		liberation(s_etat_processus, (*l_element_courant).donnee);
		free(l_element_courant);
		l_element_courant = l_element_suivant;
	}

	(*s_etat_processus).l_base_pile_contextes = NULL;

	return;
}


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

void
instruction_continue(struct_processus *s_etat_processus)
{
	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  CONTINUE ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(relance d'un processus suspendu)\n\n");
		}
		else
		{
			printf("(continue a pending process)\n\n");
		}

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

		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 == PRC)
	{
		if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
				!= 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
		}
		else
		{
			l_element_courant = (struct_liste_chainee *)
					(*s_etat_processus).l_base_pile_processus;

			while(l_element_courant != NULL)
			{
				if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
						.processus_detache == d_vrai)
				{
					if ((*(*((struct_processus_fils *) (*s_objet).objet))
							.thread).pid == (*(*((struct_processus_fils *)
							(*(*l_element_courant).donnee).objet)).thread).pid)
					{
						if (envoi_signal_processus(
								(*(*((struct_processus_fils *)
								(*s_objet).objet)).thread).pid, rpl_sigcont,
								d_faux) != 0)
						{
							// Le processus est peut-être dans l'état zombie.
						}

						break;
					}
				}
				else
				{
					if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
							(*s_objet).objet)).thread).mutex)) != 0)
					{
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}

					if ((*(*((struct_processus_fils *)
							(*s_objet).objet)).thread).thread_actif == d_vrai)
					{
						if (((pthread_equal((*(*((struct_processus_fils *)
								(*s_objet).objet)).thread).tid,
								(*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.tid) != 0)) && ((*(*((struct_processus_fils *)
								(*s_objet).objet)).thread).pid ==
								(*(*((struct_processus_fils *)
								(*(*l_element_courant).donnee).objet)).thread)
								.pid))
						{
							if (envoi_signal_thread(s_etat_processus,
									(*(*((struct_processus_fils *)
									(*s_objet).objet)).thread).tid, rpl_sigcont)
									!= 0)
							{
								// Le thread est peut-être dans l'état zombie.
							}

							if (pthread_mutex_unlock(
									&((*(*((struct_processus_fils *)
									(*s_objet).objet)).thread).mutex)) != 0)
							{
								pthread_mutex_unlock(&((*s_etat_processus)
										.mutex_pile_processus));
								(*s_etat_processus).erreur_systeme =
										d_es_processus;
								return;
							}

							break;
						}
					}

					if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
							(*s_objet).objet)).thread).mutex)) != 0)
					{
						pthread_mutex_unlock(&((*s_etat_processus)
								.mutex_pile_processus));
						(*s_etat_processus).erreur_systeme = d_es_processus;
						return;
					}
				}

				l_element_courant = (*l_element_courant).suivant;
			}

			if (pthread_mutex_unlock(&((*s_etat_processus)
					.mutex_pile_processus)) != 0)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
			}
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet);

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

	liberation(s_etat_processus, s_objet);

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(capture du signal stop)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(catch stop signal)\n\n");
			printf("  No argument\n");
		}

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}
	
	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}
	}

	if ((*s_etat_processus).var_volatile_traitement_retarde_stop == 0)
	{
		(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;
	}
	else
	{
		(*s_etat_processus).erreur_execution = d_ex_stop;
	}

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(libère un fusible)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(release fuse signal)\n\n");
			printf("  No argument\n");
		}

		return;
	}
	else if ((*s_etat_processus).test_instruction == 'Y')
	{
		(*s_etat_processus).nombre_arguments = -1;
		return;
	}
	
	if (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}
	}

	if ((*s_etat_processus).presence_fusible == d_faux)
	{
		(*s_etat_processus).erreur_execution = d_ex_fusible;
		return;
	}

	if (pthread_cancel((*s_etat_processus).thread_fusible) != 0)
	{
		if ((*s_etat_processus).var_volatile_requete_arret == 0)
		{
			(*s_etat_processus).erreur_systeme = d_es_processus;
			return;
		}
	}

	(*s_etat_processus).thread_fusible = 0;
	(*s_etat_processus).presence_fusible = d_faux;

	return;
}


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

static struct_objet *
creation_table(struct_processus *s_etat_processus,
		struct_liste_chainee *dimensions)
{
	struct_objet		*s_table;

	integer8			i;

	if ((s_table = allocation(s_etat_processus, TBL)) == NULL)
	{
		return(NULL);
	}

	(*((struct_tableau *) (*s_table).objet)).nombre_elements =
			(*((integer8 *) (*(*dimensions).donnee).objet));

	dimensions = (*dimensions).suivant;

	if (((*((struct_tableau *) (*s_table).objet)).elements =
			malloc(((size_t) (*((struct_tableau *) (*s_table).objet))
			.nombre_elements) * sizeof(struct_objet *))) == NULL)
	{
		return(NULL);
	}

	if (dimensions == NULL)
	{
		for(i = 0; i < (*((struct_tableau *) (*s_table).objet))
				.nombre_elements; i++)
		{
			if (((*((struct_tableau *) (*s_table).objet)).elements[i] =
					allocation(s_etat_processus, LST)) == NULL)
			{
				return(NULL);
			}
		}
	}
	else
	{
		for(i = 0; i < (*((struct_tableau *) (*s_table).objet))
				.nombre_elements; i++)
		{
			if (((*((struct_tableau *) (*s_table).objet)).elements[i] =
					creation_table(s_etat_processus, dimensions)) == NULL)
			{
				return(NULL);
			}
		}
	}

	return(s_table);
}

void
instruction_crtab(struct_processus *s_etat_processus)
{
	struct_liste_chainee	*l_element_courant;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(création d'une table régulière)\n\n");
		}
		else
		{
			printf("(create a regular table)\n\n");
		}

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

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

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

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

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

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

			l_element_courant = (*l_element_courant).suivant;
		}

		if ((s_objet_resultat = creation_table(s_etat_processus,
					(*s_objet_argument).objet)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument);

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

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

	liberation(s_etat_processus, s_objet_argument);

	return;
}

// vim: ts=4