/*
================================================================================
  RPL/2 (R) version 4.0.11
  Copyright (C) 1989-2010 Dr. BERTRAND Joël

  This file is part of RPL/2.

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


#include "rpl.conv.h"


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

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

	struct_objet			*s_objet_resultat;

	unsigned long			i;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(mémoire occupée)\n\n");
		}
		else
		{
			printf("(used memory)\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 (test_cfsf(s_etat_processus, 31) == d_vrai)
	{
		if (empilement_pile_last(s_etat_processus, 0) == d_erreur)
		{
			return;
		}
	}

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

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

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

	/*
	 * Décompte de la mémoire utilisée dans la pile
	 */

	(*((integer8 *) (*((*((struct_liste_chainee *) (*s_objet_resultat).objet))
			.donnee)).objet)) = 0;

	l_element_courant = (*s_etat_processus).l_base_pile;

	while(l_element_courant != NULL)
	{
		(*((integer8 *) (*((*((struct_liste_chainee *) (*s_objet_resultat)
				.objet)).donnee)).objet)) += occupation_memoire(
				(*l_element_courant).donnee);
		l_element_courant = (*l_element_courant).suivant;
	}

	/*
	 * Décompte de la mémoire utilisée pour les différentes variables
	 */

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

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

	(*((*((struct_liste_chainee *) (*s_objet_resultat).objet)).suivant))
			.suivant = NULL;

	(*((integer8 *) (*((*((*((struct_liste_chainee *)
			(*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0;

	for(i = 0; i < (*s_etat_processus).nombre_variables; i++)
	{
		(*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)
				.objet)).suivant)).donnee)).objet)) += sizeof(unsigned char) *
				strlen((*s_etat_processus).s_liste_variables[i].nom);
		(*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)
				.objet)).suivant)).donnee)).objet)) += occupation_memoire(
				(*s_etat_processus).s_liste_variables[i].objet);
	}

	for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)
	{
		// Comptabilisation des empreintes mémoire des variables
		// statiques qui ne sont pas accessibles, les variables statiques
		// accessibles étant déjà comptabilitées par la boucle précédente.

		if ((*s_etat_processus).s_liste_variables_statiques[i].objet != NULL)
		{
			(*((integer8 *) (*((*((*((struct_liste_chainee *)
					(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
					sizeof(unsigned char) * strlen((*s_etat_processus)
					.s_liste_variables_statiques[i].nom);
			(*((integer8 *) (*((*((*((struct_liste_chainee *)
					(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
					occupation_memoire((*s_etat_processus)
					.s_liste_variables_statiques[i].objet);
		}
	}

	for(i = 0; i < (*(*s_etat_processus).s_liste_variables_partagees)
			.nombre_variables; i++)
	{
		(*((integer8 *) (*((*((*((struct_liste_chainee *)
				(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
				sizeof(unsigned char) * strlen((*(*s_etat_processus)
				.s_liste_variables_partagees).table[i].nom);
		(*((integer8 *) (*((*((*((struct_liste_chainee *)
				(*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=
				occupation_memoire((*(*s_etat_processus)
				.s_liste_variables_partagees).table[i].objet);
	}

	/*
	 * Empilement du résultat
	 */

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

	return;
}


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

void
instruction_mclrin(struct_processus *s_etat_processus)
{
	logical1					last_valide;

	struct_liste_chainee		*l_liste;

	struct_objet				*s_objet;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(série de MacLaurin)\n\n");
		}
		else
		{
			printf("(MacLaurin serie)\n\n");
		}

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

		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, 3) == d_erreur)
		{
			return;
		}
	}

	if ((*s_etat_processus).hauteur_pile_operationnelle < 3)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

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

	(*((integer8 *) (*s_objet).objet)) = 0;

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

	l_liste = (*s_etat_processus).l_base_pile;
	(*s_etat_processus).l_base_pile = (*l_liste).suivant;
	(*l_liste).suivant = (*(*s_etat_processus).l_base_pile).suivant;
	(*(*s_etat_processus).l_base_pile).suivant = l_liste;

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

	instruction_taylr(s_etat_processus);

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

	return;
}


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

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

	struct_objet				*s_objet_argument;

	unsigned char				*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

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

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

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

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

	if ((*s_objet_argument).type == MTX)
	{
		l_element_courant = (*s_etat_processus).liste_mutexes;

		while(l_element_courant != NULL)
		{
			if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
					.mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
					.mutex))
			{
				break;
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if (l_element_courant == NULL)
		{
			(*s_etat_processus).erreur_execution = d_ex_mutex;

			liberation(s_etat_processus, s_objet_argument);
			return;
		}

		if ((*s_etat_processus).profilage == d_vrai)
		{
			if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			profilage(s_etat_processus, tampon);
			free(tampon);

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

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

		if (pthread_mutex_lock(&((*((struct_mutex *) (*s_objet_argument).objet))
				.mutex)) != 0)
		{
			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
			{
				if ((*s_etat_processus).profilage == d_vrai)
				{
					profilage(s_etat_processus, NULL);
				}

				if (errno != EINTR)
				{
					(*s_etat_processus).erreur_systeme = d_es_processus;
					return;
				}
			}

			liberation(s_etat_processus, s_objet_argument);

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

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

		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
		{
			if (errno != EINTR)
			{
				(*s_etat_processus).erreur_systeme = d_es_processus;
				return;
			}
		}

		if ((*s_etat_processus).profilage == d_vrai)
		{
			profilage(s_etat_processus, NULL);
		}
	}
	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 'mtxtrylock'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_mtxtrylock(struct_processus *s_etat_processus)
{
	int							ios;

	struct_liste_chainee		*l_element_courant;

	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_resultat;

	unsigned char				*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(essai de verrouillage du mutex)\n\n");
		}
		else
		{
			printf("(try to lock mutex)\n\n");
		}

		printf("    1: %s\n", d_MTX);
		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 == MTX)
	{
		l_element_courant = (*s_etat_processus).liste_mutexes;

		while(l_element_courant != NULL)
		{
			if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
					.mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
					.mutex))
			{
				break;
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if (l_element_courant == NULL)
		{
			(*s_etat_processus).erreur_execution = d_ex_mutex;

			liberation(s_etat_processus, s_objet_argument);
			return;
		}

		if ((*s_etat_processus).profilage == d_vrai)
		{
			if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			profilage(s_etat_processus, tampon);
			free(tampon);

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

		if ((ios = pthread_mutex_trylock(&((*((struct_mutex *)
				(*s_objet_argument).objet)).mutex))) != 0)
		{
			if (ios != EBUSY)
			{
				liberation(s_etat_processus, s_objet_argument);

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

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

		if ((*s_etat_processus).profilage == d_vrai)
		{
			profilage(s_etat_processus, NULL);
		}
	}
	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 ((s_objet_resultat = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;

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

	return;
}

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

void
instruction_mtxstatus(struct_processus *s_etat_processus)
{
	int							ios;

	struct_liste_chainee		*l_element_courant;

	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_resultat;

	unsigned char				*tampon;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(statut du mutex)\n\n");
		}
		else
		{
			printf("(mutex status)\n\n");
		}

		printf("    1: %s\n", d_MTX);
		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 == MTX)
	{
		l_element_courant = (*s_etat_processus).liste_mutexes;

		while(l_element_courant != NULL)
		{
			if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
					.mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
					.mutex))
			{
				break;
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if (l_element_courant == NULL)
		{
			(*s_etat_processus).erreur_execution = d_ex_mutex;

			liberation(s_etat_processus, s_objet_argument);
			return;
		}

		if ((*s_etat_processus).profilage == d_vrai)
		{
			if ((tampon = formateur(s_etat_processus, 0, s_objet_argument))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			profilage(s_etat_processus, tampon);
			free(tampon);

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

		if ((ios = pthread_mutex_trylock(&((*((struct_mutex *)
				(*s_objet_argument).objet)).mutex))) != 0)
		{
			if (ios != EBUSY)
			{
				liberation(s_etat_processus, s_objet_argument);

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

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

		if (pthread_mutex_unlock(&((*((struct_mutex *)
				(*s_objet_argument).objet)).mutex)) != 0)
		{
			liberation(s_etat_processus, s_objet_argument);

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

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

		if ((*s_etat_processus).profilage == d_vrai)
		{
			profilage(s_etat_processus, NULL);
		}
	}
	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 ((s_objet_resultat = allocation(s_etat_processus, INT))
			== NULL)
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	(*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;

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

	return;
}


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

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

	struct_objet				*s_objet_argument;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

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

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

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

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

	if ((*s_objet_argument).type == MTX)
	{
		l_element_courant = (*s_etat_processus).liste_mutexes;

		while(l_element_courant != NULL)
		{
			if (&((*((struct_mutex *) (*(*l_element_courant).donnee).objet))
					.mutex) == &((*((struct_mutex *) (*s_objet_argument).objet))
					.mutex))
			{
				break;
			}

			l_element_courant = (*l_element_courant).suivant;
		}

		if (l_element_courant == NULL)
		{
			(*s_etat_processus).erreur_execution = d_ex_mutex;

			liberation(s_etat_processus, s_objet_argument);
			return;
		}

		if (pthread_mutex_trylock(&((*((struct_mutex *)
				(*s_objet_argument).objet)).mutex)) == EINVAL)
		{
			liberation(s_etat_processus, s_objet_argument);

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

		if (pthread_mutex_unlock(&((*((struct_mutex *)
				(*s_objet_argument).objet)).mutex)) != 0)
		{
			liberation(s_etat_processus, s_objet_argument);

			(*s_etat_processus).erreur_systeme = d_es_processus;
			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 'mark'
================================================================================
  Entrées :
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

void
instruction_mark(struct_processus *s_etat_processus)
{
	struct_marque				*marque;

	struct_objet				*s_objet_argument;
	struct_objet				*s_objet_label;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(ajoute une marque à un graphique)\n\n");
		}
		else
		{
			printf("(add mark to graph)\n\n");
		}

		printf("    2: %s\n", d_CHN);
		printf("    1: %s\n", d_CPL);

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

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

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_label) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument);

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

	if (((*s_objet_argument).type == CPL) && ((*s_objet_label).type == CHN))
	{
		if ((marque = malloc(sizeof(struct_marque))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

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

		sprintf((*marque).label, "%s",
				(unsigned char *) (*s_objet_label).objet);

		if (((*marque).position = malloc(64 * sizeof(unsigned char))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		sprintf((*marque).position, "%f,%f",
				(*((complex16 *) (*s_objet_argument).objet)).partie_reelle,
				(*((complex16 *) (*s_objet_argument).objet)).partie_imaginaire);

		(*marque).suivant = (*s_etat_processus).s_marques;
		(*s_etat_processus).s_marques = marque;

		(*s_etat_processus).mise_a_jour_trace_requise = d_vrai;
	}
	else
	{
		liberation(s_etat_processus, s_objet_argument);
		liberation(s_etat_processus, s_objet_label);

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

	liberation(s_etat_processus, s_objet_argument);
	liberation(s_etat_processus, s_objet_label);

	return;
}

// vim: ts=4