/*
================================================================================
  RPL/2 (R) version 4.0.20
  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 'dec'
================================================================================
  Entrées : structure processus
--------------------------------------------------------------------------------
  Sorties :
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(base 10)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(decimal base)\n\n");
			printf("  No argument\n");
		}

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

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

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

	return;
}


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

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

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(arguments en degres)\n\n");
			printf("  Aucun argument\n");
		}
		else
		{
			printf("(degrees)\n\n");
			printf("  No argument\n");
		}

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

	cf(s_etat_processus, 60);

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

	return;
}


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

void
instruction_depth(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  DEPTH ");

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(profondeur de la pile)\n\n");
		}
		else
		{
			printf("(stack depth)\n\n");
		}

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

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

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

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

	(*((integer8 *) ((*s_objet).objet))) = (integer8)
			(*s_etat_processus).hauteur_pile_operationnelle;

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

    return;
}


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

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

	unsigned char					*chaine;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

		printf("    1: %s, %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s, %s,\n"
				"       %s, %s, %s, %s,\n"
				"       %s, %s\n",
				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
				d_SQL, d_SLB, d_PRC, d_MTX);

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

	chaine = formateur(s_etat_processus, 0, s_objet);

	if (chaine != NULL)
	{
		flockfile(stdout);
		fprintf(stdout, "%s", chaine);

		if (test_cfsf(s_etat_processus, 33) == d_faux)
		{
			fprintf(stdout, "\n");
		}

		funlockfile(stdout);

		if (test_cfsf(s_etat_processus, 32) == d_vrai)
		{
			formateur_tex(s_etat_processus, s_objet, 'N');
		}

		free(chaine);
	}
	else
	{
		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
		return;
	}

	liberation(s_etat_processus, s_objet);

	return;
}


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

void
instruction_drop(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  DROP ");

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

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

		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 ((*s_etat_processus).l_base_pile == NULL)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		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;
	}

	liberation(s_etat_processus, s_objet);

	return;
}


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

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

	logical1						erreur;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(effacement de deux objets)\n\n");
		}
		else
		{
			printf("(drop two objects)\n\n");
		}

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

		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 ((*s_etat_processus).hauteur_pile_operationnelle < 2)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	erreur = depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet);
	liberation(s_etat_processus, s_objet);

	erreur = depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet);
	liberation(s_etat_processus, s_objet);

	return;
}


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

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

	signed long						nombre_suppressions;

	unsigned long					i;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(effacement de n objets)\n\n");
		}
		else
		{
			printf("(drop n objects)\n\n");
		}

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

		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)
	{
		return;
	}

	if ((*s_objet).type != INT)
	{
		liberation(s_etat_processus, s_objet);

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

	nombre_suppressions = (*((integer8 *) (*s_objet).objet));
	liberation(s_etat_processus, s_objet);

	if (nombre_suppressions < 0)
	{

/*
-- Opération absurde autorisée sur le calculateur HP-28S -----------------------
*/

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

	if ((unsigned long) nombre_suppressions >
			(*s_etat_processus).hauteur_pile_operationnelle)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	for(i = 0; i < (unsigned long) nombre_suppressions; i++)
	{
		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
				&s_objet) == d_erreur)
		{
			return;
		}

		liberation(s_etat_processus, s_objet);
	}

	return;
}


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

void
instruction_dup(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  DUP ");

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

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

		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 ((*s_etat_processus).l_base_pile == NULL)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	s_objet = copie_objet(s_etat_processus,
			(*(*s_etat_processus).l_base_pile).donnee, 'P');

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

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

	return;
}


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

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

	unsigned long					i;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(duplication de deux objets)\n\n");
		}
		else
		{
			printf("(duplication of two objects)\n\n");
		}

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

		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 ((*s_etat_processus).hauteur_pile_operationnelle < 2)
	{
		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
		return;
	}

	for(i = 0; i < 2; i++)
	{
		s_objet = copie_objet(s_etat_processus,
				(*(*(*s_etat_processus).l_base_pile).suivant).donnee, 'P');

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

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

	return;
}


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

void
instruction_dupn(struct_processus *s_etat_processus)
{
	struct_liste_chainee				*l_base_pile;
	struct_liste_chainee				*l_element_courant;

	struct_objet						*s_objet;
	struct_objet						*s_nouvel_objet;

	signed long							nombre_duplications;
	unsigned long						i;

	(*s_etat_processus).erreur_execution = d_ex;

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

		if ((*s_etat_processus).langue == 'F')
		{
			printf("(duplication de n objets)\n\n");
		}
		else
		{
			printf("(duplication of n objects)\n\n");
		}

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

		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)
	{
		return;
	}

	if ((*s_objet).type != INT)
	{
		liberation(s_etat_processus, s_objet);

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

	nombre_duplications = (*((integer8 *) (*s_objet).objet));
	liberation(s_etat_processus, s_objet);

	if (nombre_duplications < 0)
	{

/*
-- Opération absurde autorisée sur le calculateur HP-28S -----------------------
*/

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

	l_element_courant = (*s_etat_processus).l_base_pile;

	for(i = 0; i < (unsigned long) nombre_duplications; i++)
	{
		if (l_element_courant == NULL)
		{
			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
			return;
		}

		s_nouvel_objet = copie_objet(s_etat_processus,
				(*l_element_courant).donnee, 'P');

		if (s_nouvel_objet == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (empilement(s_etat_processus, &l_base_pile, s_nouvel_objet)
				== d_erreur)
		{
			return;
		}

		l_element_courant = (*l_element_courant).suivant;
	}

	for(i = 0; i < (unsigned long) nombre_duplications; i++)
	{
		if (depilement(s_etat_processus, &l_base_pile, &s_objet) == d_erreur)
		{
			return;
		}

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

	return;
}


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

void
instruction_division(struct_processus *s_etat_processus)
{
	integer8						reste;

	real8							dividende_reel;
	real8							diviseur_reel;

	logical1						drapeau;
	logical1						resultat_entier;

	struct_complexe16				accumulateur;

	struct_liste_chainee			*l_element_courant;
	struct_liste_chainee			*l_element_precedent;

	struct_objet					*s_copie_argument_1;
	struct_objet					*s_copie_argument_2;
	struct_objet					*s_objet_argument_1;
	struct_objet					*s_objet_argument_2;
	struct_objet					*s_objet_resultat;

	unsigned long					i;
	unsigned long					j;
	unsigned long					k;
	unsigned long					nombre_elements;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

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

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

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

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

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

		printf("    2: %s, %s, %s\n", d_VIN, d_VRL, d_VCX);
		printf("    1: %s, %s, %s\n", d_INT, d_REL, d_CPL);
		printf("->  1: %s, %s, %s\n\n", d_VIN, d_VRL, d_VCX);

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

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

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

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

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

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

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

	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
			&s_objet_argument_2) == d_erreur)
	{
		liberation(s_etat_processus, s_objet_argument_1);

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

/*
--------------------------------------------------------------------------------
  Division donnant un résultat réel (ou entier si cela reste correct)
--------------------------------------------------------------------------------
*/

	if ((((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL)) &&
			(((*s_objet_argument_2).type == INT) ||
			((*s_objet_argument_2).type == REL)))
	{
		if (((*s_objet_argument_2).type == INT) &&
				((*s_objet_argument_1).type == INT))
		{
			if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
			{
				reste = -1;
			}
			else
			{
				reste = (*((integer8 *) (*s_objet_argument_2).objet)) %
						(*((integer8 *) (*s_objet_argument_1).objet));
			}
		}
		else
		{
			reste = -1;
		}

		if (reste == 0)
		{
			/*
			 * Résultat entier
			 */

			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)) = (*((integer8 *)
					(*s_objet_argument_2).objet)) / (*((integer8 *)
					(*s_objet_argument_1).objet));
		}
		else
		{
			/*
			 * Résultat réel
			 */

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

			if ((*s_objet_argument_1).type == INT)
			{
				diviseur_reel = (real8) (*((integer8 *)
						(*s_objet_argument_1).objet));
			}
			else
			{
				diviseur_reel = (*((real8 *) (*s_objet_argument_1).objet));
			}

			if ((*s_objet_argument_2).type == INT)
			{
				dividende_reel = (real8) (*((integer8 *)
						(*s_objet_argument_2).objet));
			}
			else
			{
				dividende_reel = (*((real8 *) (*s_objet_argument_2).objet));
			}

			if ((diviseur_reel == 0) && (test_cfsf(s_etat_processus, 59) ==
					d_vrai))
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);
				liberation(s_etat_processus, s_objet_resultat);

				(*s_etat_processus).exception = d_ep_division_par_zero;
				return;
			}

			(*((real8 *) (*s_objet_resultat).objet)) = dividende_reel /
					diviseur_reel;
		}
	}

/*
--------------------------------------------------------------------------------
  Division donnant un résultat complexe
--------------------------------------------------------------------------------
*/

	else if ((((*s_objet_argument_1).type == CPL) &&
			(((*s_objet_argument_2).type == INT) ||
			((*s_objet_argument_2).type == REL) ||
			((*s_objet_argument_2).type == CPL))) ||
			(((*s_objet_argument_2).type == CPL) &&
			(((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL) ||
		   	((*s_objet_argument_1).type == CPL))))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, CPL)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*s_objet_argument_1).type == CPL)
		{
			if (((*((struct_complexe16 *) (*s_objet_argument_1).objet))
					.partie_reelle == 0) && ((*((struct_complexe16 *)
					(*s_objet_argument_1).objet)).partie_imaginaire == 0))
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);
				liberation(s_etat_processus, s_objet_resultat);

				(*s_etat_processus).exception = d_ep_division_par_zero;
				return;
			}

			if ((*s_objet_argument_2).type == INT)
			{
				f77divisionic_(&((*((integer8 *) (*s_objet_argument_2)
						.objet))), &((*((struct_complexe16 *)
						(*s_objet_argument_1).objet))),
						&((*((struct_complexe16 *)
						(*s_objet_resultat).objet))));
			}
			else if ((*s_objet_argument_2).type == REL)
			{
				f77divisionrc_(&((*((real8 *) (*s_objet_argument_2)
						.objet))), &((*((struct_complexe16 *)
						(*s_objet_argument_1).objet))),
						&((*((struct_complexe16 *)
						(*s_objet_resultat).objet))));
			}
			else
			{
				f77divisioncc_(&((*((struct_complexe16 *) (*s_objet_argument_2)
						.objet))), &((*((struct_complexe16 *)
						(*s_objet_argument_1).objet))),
						&((*((struct_complexe16 *)
						(*s_objet_resultat).objet))));
			}
		}
		else
		{
			if ((*s_objet_argument_1).type == INT)
			{
				if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
				{
					liberation(s_etat_processus, s_objet_argument_1);
					liberation(s_etat_processus, s_objet_argument_2);
					liberation(s_etat_processus, s_objet_resultat);

					(*s_etat_processus).exception = d_ep_division_par_zero;
					return;
				}

				f77divisionci_(&((*((struct_complexe16 *) (*s_objet_argument_2)
						.objet))), &((*((integer8 *)
						(*s_objet_argument_1).objet))),
						&((*((struct_complexe16 *)
						(*s_objet_resultat).objet))));
			}
			else
			{
				if ((*((real8 *) (*s_objet_argument_1).objet)) == 0)
				{
					liberation(s_etat_processus, s_objet_argument_1);
					liberation(s_etat_processus, s_objet_argument_2);
					liberation(s_etat_processus, s_objet_resultat);

					(*s_etat_processus).exception = d_ep_division_par_zero;
					return;
				}

				f77divisioncr_(&((*((struct_complexe16 *) (*s_objet_argument_2)
						.objet))), &((*((real8 *)
						(*s_objet_argument_1).objet))),
						&((*((struct_complexe16 *)
						(*s_objet_resultat).objet))));
			}
		}
	}

/*
--------------------------------------------------------------------------------
  Division mettant en oeuvre un nom ou une expression algébrique
--------------------------------------------------------------------------------
*/
	/*
	 * Nom ou valeur numérique / Nom ou valeur numérique
	 */

	else if ((((*s_objet_argument_1).type == NOM) &&
			(((*s_objet_argument_2).type == NOM) ||
			((*s_objet_argument_2).type == INT) ||
			((*s_objet_argument_2).type == REL) ||
			((*s_objet_argument_2).type == CPL))) ||
			(((*s_objet_argument_2).type == NOM) &&
			(((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL) ||
			((*s_objet_argument_1).type == CPL))))
	{
		drapeau = d_vrai;

		if ((*s_objet_argument_2).type == NOM)
		{
			if ((*s_objet_argument_1).type == INT)
			{
				if ((*((integer8 *) (*s_objet_argument_1).objet)) == 1)
				{ // Division par 1
					drapeau = d_faux;

					s_objet_resultat = s_objet_argument_2;
					s_objet_argument_2 = NULL;
				}
			}
			else if ((*s_objet_argument_1).type == REL)
			{
				if ((*((real8 *) (*s_objet_argument_1).objet)) == 1)
				{ // Division par 1.0
					drapeau = d_faux;

					s_objet_resultat = s_objet_argument_2;
					s_objet_argument_2 = NULL;
				}
			}
			else if ((*s_objet_argument_1).type == CPL)
			{
				if (((*((complex16 *) (*s_objet_argument_1).objet))
						.partie_reelle == 1) && ((*((complex16 *)
						(*s_objet_argument_1).objet)).partie_imaginaire == 0))
				{ // Division par (1.0,0.0)
					drapeau = d_faux;

					s_objet_resultat = s_objet_argument_2;
					s_objet_argument_2 = NULL;
				}
			}
		}
		else if ((*s_objet_argument_1).type == NOM)
		{
			if ((*s_objet_argument_2).type == INT)
			{
				if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
				{ // Dividende nul
					drapeau = d_faux;

					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)) = 0;
				}
			}
			else if ((*s_objet_argument_2).type == REL)
			{
				if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
				{ // Dividende nul
					drapeau = d_faux;

					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)) = 0;
				}
			}
			else if ((*s_objet_argument_2).type == CPL)
			{
				if (((*((complex16 *) (*s_objet_argument_2).objet))
						.partie_reelle == 0) && ((*((complex16 *)
						(*s_objet_argument_2).objet)).partie_imaginaire == 0))
				{ // Dividende nul
					drapeau = d_faux;

					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)) = 0;
				}
			}
		}

		if (drapeau == d_vrai)
		{
			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_2;

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

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

			if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
					.nom_fonction = malloc(2 * 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;

			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_1 = NULL;
			s_objet_argument_2 = NULL;
		}
	}

	/*
	 * Nom ou valeur numérique / Expression
	 */

	else if ((((*s_objet_argument_1).type == ALG) ||
			((*s_objet_argument_1).type == RPN)) &&
			(((*s_objet_argument_2).type == NOM) ||
			((*s_objet_argument_2).type == INT) ||
			((*s_objet_argument_2).type == REL) ||
			((*s_objet_argument_2).type == CPL)))
	{
		drapeau = d_vrai;

		nombre_elements = 0;
		l_element_courant = (struct_liste_chainee *)
				(*s_objet_argument_1).objet;

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

		if (nombre_elements == 2)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_1);

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

		if ((*s_objet_argument_2).type == INT)
		{
			if ((*((integer8 *) (*s_objet_argument_2).objet)) == 0)
			{
				drapeau = d_faux;

				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)) = 0;
			}
		}
		else if ((*s_objet_argument_2).type == REL)
		{
			if ((*((real8 *) (*s_objet_argument_2).objet)) == 0)
			{
				drapeau = d_faux;

				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)) = 0;
			}
		}
		else if ((*s_objet_argument_2).type == CPL)
		{
			if (((*((complex16 *) (*s_objet_argument_2).objet))
					.partie_reelle == 0) && ((*((complex16 *)
					(*s_objet_argument_2).objet)).partie_imaginaire == 0))
			{
				drapeau = d_faux;

				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)) = 0;
			}
		}

		if (drapeau == d_vrai)
		{
			if ((s_objet_resultat = copie_objet(s_etat_processus,
					s_objet_argument_1, 'N')) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_resultat).objet;
			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;
			}

			(*(*l_element_precedent).suivant).donnee = s_objet_argument_2;
			(*(*l_element_precedent).suivant).suivant = 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 = 0;
			(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
					.donnee).objet)).fonction = instruction_division;

			if (((*((struct_fonction *) (*(*(*l_element_precedent)
					.suivant).donnee).objet)).nom_fonction =
					malloc(2 * 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, "/");

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

			s_objet_argument_2 = NULL;
		}
	}

	/*
	 * Expression / Nom ou valeur numérique
	 */

	else if ((((*s_objet_argument_1).type == NOM) ||
			((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL) ||
			((*s_objet_argument_1).type == CPL)) &&
			(((*s_objet_argument_2).type == ALG) ||
			((*s_objet_argument_2).type == RPN)))
	{
		drapeau = d_vrai;

		nombre_elements = 0;
		l_element_courant = (struct_liste_chainee *)
				(*s_objet_argument_2).objet;

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

		if (nombre_elements == 2)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		if ((*s_objet_argument_1).type == INT)
		{
			if ((*((integer8 *) (*s_objet_argument_1).objet)) == 1)
			{
				drapeau = d_faux;

				s_objet_resultat = s_objet_argument_2;
				s_objet_argument_2 = NULL;
			}
		}
		else if ((*s_objet_argument_1).type == REL)
		{
			if ((*((real8 *) (*s_objet_argument_1).objet)) == 1)
			{
				drapeau = d_faux;

				s_objet_resultat = s_objet_argument_2;
				s_objet_argument_2 = NULL;
			}
		}
		else if ((*s_objet_argument_1).type == CPL)
		{
			if (((*((complex16 *) (*s_objet_argument_1).objet))
					.partie_reelle == 1) && ((*((complex16 *)
					(*s_objet_argument_1).objet)).partie_imaginaire == 0))
			{
				drapeau = d_faux;

				s_objet_resultat = s_objet_argument_2;
				s_objet_argument_2 = NULL;
			}
		}

		if (drapeau == d_vrai)
		{
			if ((s_objet_resultat = copie_objet(s_etat_processus,
					s_objet_argument_2, 'N')) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			l_element_courant = (struct_liste_chainee *)
					(*s_objet_resultat).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;
			}

			(*(*l_element_precedent).suivant).donnee = s_objet_argument_1;
			l_element_precedent = (*l_element_precedent).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 = 0;
			(*((struct_fonction *) (*(*(*l_element_precedent).suivant)
					.donnee).objet)).fonction = instruction_division;

			if (((*((struct_fonction *) (*(*(*l_element_precedent)
					.suivant).donnee).objet)).nom_fonction =
					malloc(2 * 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, "/");

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

			s_objet_argument_1 = NULL;
		}
	}

	/*
	 * Expression / Expression
	 */

	else if ((((*s_objet_argument_1).type == ALG) &&
			((*s_objet_argument_2).type == ALG)) ||
			(((*s_objet_argument_1).type == RPN) &&
			((*s_objet_argument_2).type == RPN)))
	{
		nombre_elements = 0;
		l_element_courant = (struct_liste_chainee *)
				(*s_objet_argument_1).objet;

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

		if (nombre_elements == 2)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

		nombre_elements = 0;
		l_element_courant = (struct_liste_chainee *)
				(*s_objet_argument_2).objet;

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

		if (nombre_elements == 2)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

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

		l_element_courant = (struct_liste_chainee *)
				(*s_copie_argument_1).objet;
		(*s_copie_argument_1).objet = (*((struct_liste_chainee *)
				(*s_copie_argument_1).objet)).suivant;

		liberation(s_etat_processus, (*l_element_courant).donnee);
		free(l_element_courant);

		l_element_courant = (struct_liste_chainee *)
				(*s_copie_argument_2).objet;
		l_element_precedent = l_element_courant;
		s_objet_resultat = s_copie_argument_2;

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

		liberation(s_etat_processus, (*l_element_courant).donnee);
		free(l_element_courant);

		(*l_element_precedent).suivant = (struct_liste_chainee *)
				(*s_copie_argument_1).objet;
		free(s_copie_argument_1);

		l_element_courant = (*l_element_precedent).suivant;
		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;
		}

		(*(*l_element_precedent).suivant).suivant = l_element_courant;
		l_element_courant = (*l_element_precedent).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_division;

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

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

/*
--------------------------------------------------------------------------------
  Division d'un vecteur par un scalaire
--------------------------------------------------------------------------------
*/
	/*
	 * Vecteur d'entiers ou de réels / Entier ou réel
	 */

	else if ((((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL)) &&
			(((*s_objet_argument_2).type == VIN) ||
			((*s_objet_argument_2).type == VRL)))
	{
		resultat_entier = d_faux;

		if (((*s_objet_argument_2).type == VIN) &&
				((*s_objet_argument_1).type == INT))
		{
			if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
			{
				resultat_entier = d_faux;
			}
			else
			{
				resultat_entier = d_vrai;

				for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument_2)
						.objet))).taille; i++)
				{
					if ((((integer8 *) (*((struct_vecteur *)
							(*s_objet_argument_2).objet)).tableau)[i] %
							(*((integer8 *) (*s_objet_argument_1).objet))) != 0)
					{
						resultat_entier = d_faux;
					}
				}
			}
		}

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

			(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
					(*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;

			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
					 malloc((*(((struct_vecteur *) (*s_objet_resultat)
					.objet))).taille * sizeof(integer8))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
					.objet))).taille; i++)
			{
				((integer8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
						.tableau)[i] = ((integer8 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[i] / (*((integer8 *) (*s_objet_argument_1)
						.objet));
			}
		}
		else
		{
			if ((s_objet_resultat = allocation(s_etat_processus, VRL))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
					(*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;

			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
					malloc((*(((struct_vecteur *) (*s_objet_resultat)
					.objet))).taille * sizeof(real8))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			if ((*s_objet_argument_1).type == INT)
			{
				diviseur_reel = (real8) (*((integer8 *)
						(*s_objet_argument_1).objet));
			}
			else
			{
				diviseur_reel = (*((real8 *) (*s_objet_argument_1).objet));
			}

			if ((diviseur_reel == 0) && (test_cfsf(s_etat_processus, 59) ==
					d_vrai))
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);
				liberation(s_etat_processus, s_objet_resultat);

				(*s_etat_processus).exception = d_ep_division_par_zero;
				return;
			}

			for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
					.objet))).taille; i++)
			{
				if ((*s_objet_argument_2).type == VIN)
				{
					((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
							.tableau)[i] = (real8) ((integer8 *)
							(*((struct_vecteur *) (*s_objet_argument_2).objet))
							.tableau)[i] / diviseur_reel;
				}
				else
				{
					((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
							.tableau)[i] = ((real8 *)
							(*((struct_vecteur *) (*s_objet_argument_2).objet))
							.tableau)[i] / diviseur_reel;
				}
			}
		}
	}

	/*
	 * Vecteur d'entiers ou de réels / Complexe
	 */

	else if (((*s_objet_argument_1).type == CPL) &&
			(((*s_objet_argument_2).type == VIN) ||
			((*s_objet_argument_2).type == VRL)))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				(*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
				.objet))).taille * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_complexe16 *) (*s_objet_argument_1).objet))
				.partie_reelle == 0) && (((*((struct_complexe16 *)
				(*s_objet_argument_1).objet)).partie_imaginaire == 0)))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

			(*s_etat_processus).exception = d_ep_division_par_zero;
			return;
		}

		for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
				.objet))).taille; i++)
		{
			if ((*s_objet_argument_2).type == VIN)
			{
				f77divisionic_(&(((integer8 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[i]), &(*((struct_complexe16 *)
						(*s_objet_argument_1).objet)), &((struct_complexe16 *)
						(*((struct_vecteur *)
						(*s_objet_resultat).objet)).tableau)[i]);
			}
			else
			{
				f77divisionrc_(&(((real8 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[i]), &(*((struct_complexe16 *)
						(*s_objet_argument_1).objet)), &((struct_complexe16 *)
						(*((struct_vecteur *)
						(*s_objet_resultat).objet)).tableau)[i]);
			}
		}
	}

	/*
	 * Vecteur de complexes / Entier, réel
	 */

	else if ((((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL)) &&
			((*s_objet_argument_2).type == VCX))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, VCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				(*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
				.objet))).taille * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*s_objet_argument_1).type == INT)
		{
			diviseur_reel = (real8) (*((integer8 *)
					(*s_objet_argument_1).objet));
		}
		else
		{
			diviseur_reel = (*((real8 *) (*s_objet_argument_1).objet));
		}

		if (diviseur_reel == 0)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

			(*s_etat_processus).exception = d_ep_division_par_zero;
			return;
		}

		for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
				.objet))).taille; i++)
		{
			if ((*s_objet_argument_1).type == INT)
			{
				f77divisionci_(&(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[i]), &((*((integer8 *)
						(*s_objet_argument_1).objet))),
						&(((struct_complexe16 *) (*((struct_vecteur *)
						(*s_objet_resultat).objet)).tableau)[i]));
			}
			else
			{
				f77divisioncr_(&(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[i]), &((*((real8 *)
						(*s_objet_argument_1).objet))),
						&(((struct_complexe16 *) (*((struct_vecteur *)
						(*s_objet_resultat).objet)).tableau)[i]));
			}
		}
	}

	/*
	 * Vecteur de complexes / Complexe
	 */

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				(*((struct_vecteur *) (*s_objet_argument_2).objet)).taille;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
				.objet))).taille * sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_complexe16 *) (*s_objet_argument_1).objet))
				.partie_reelle == 0) && ((*((struct_complexe16 *)
				(*s_objet_argument_1).objet)).partie_imaginaire == 0))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

			(*s_etat_processus).exception = d_ep_division_par_zero;
			return;
		}

		for(i = 0; i < (*(((struct_vecteur *) (*s_objet_resultat)
				.objet))).taille; i++)
		{
			f77divisioncc_(&(((struct_complexe16 *)
					(*((struct_vecteur *) (*s_objet_argument_2).objet))
					.tableau)[i]), &((*((struct_complexe16 *)
					(*s_objet_argument_1).objet))),
					&(((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_resultat).objet)).tableau)[i]));
		}
	}

/*
--------------------------------------------------------------------------------
  Division d'une matrice par un scalaire
--------------------------------------------------------------------------------
*/
	/*
	 * Matrice d'entiers ou de réels / Entier ou réel
	 */

	else if ((((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL)) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL)))
	{
		resultat_entier = d_faux;

		if (((*s_objet_argument_2).type == MIN) &&
				((*s_objet_argument_1).type == INT))
		{
			if ((*((integer8 *) (*s_objet_argument_1).objet)) == 0)
			{
				resultat_entier = d_faux;
			}
			else
			{
				resultat_entier = d_vrai;

				for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument_2)
						.objet))).nombre_lignes; i++)
				{
					for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument_2)
							.objet))).nombre_colonnes; j++)
					{
						if ((((integer8 **) (*((struct_matrice *)
								(*s_objet_argument_2).objet)).tableau)[i][j] %
								(*((integer8 *) (*s_objet_argument_1).objet)))
								!= 0)
						{
							resultat_entier = d_faux;
						}
					}
				}
			}
		}

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

			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
					(*((struct_matrice *) (*s_objet_argument_2).objet))
					.nombre_lignes;
			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
					(*((struct_matrice *) (*s_objet_argument_2).objet))
					.nombre_colonnes;

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

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

				for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
						.objet))).nombre_colonnes; j++)
				{
					((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
							.objet)).tableau)[i][j] = ((integer8 **)
							(*((struct_matrice *) (*s_objet_argument_2)
							.objet)).tableau)[i][j] / (*((integer8 *)
							(*s_objet_argument_1).objet));
				}
			}
		}
		else
		{
			if ((s_objet_resultat = allocation(s_etat_processus, MRL))
					== NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
					(*((struct_matrice *) (*s_objet_argument_2).objet))
					.nombre_lignes;
			(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
					(*((struct_matrice *) (*s_objet_argument_2).objet))
					.nombre_colonnes;

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

			if ((*s_objet_argument_1).type == INT)
			{
				diviseur_reel = (real8) (*((integer8 *)
						(*s_objet_argument_1).objet));
			}
			else
			{
				diviseur_reel = (*((real8 *) (*s_objet_argument_1).objet));
			}

			if ((diviseur_reel == 0) && (test_cfsf(s_etat_processus, 59) ==
					d_vrai))
			{
				liberation(s_etat_processus, s_objet_argument_1);
				liberation(s_etat_processus, s_objet_argument_2);
				liberation(s_etat_processus, s_objet_resultat);

				(*s_etat_processus).exception = d_ep_division_par_zero;
				return;
			}

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

				for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
						.objet))).nombre_colonnes; j++)
				{
					if ((*s_objet_argument_2).type == MIN)
					{
						((real8 **) (*((struct_matrice *) (*s_objet_resultat)
								.objet)).tableau)[i][j] = (real8) ((integer8 **)
								(*((struct_matrice *) (*s_objet_argument_2)
								.objet)).tableau)[i][j] / diviseur_reel;
					}
					else
					{
						((real8 **) (*((struct_matrice *) (*s_objet_resultat)
								.objet)).tableau)[i][j] = ((real8 **)
								(*((struct_matrice *) (*s_objet_argument_2)
								.objet)).tableau)[i][j] / diviseur_reel;
					}
				}
			}
		}
	}

	/*
	 * Matrice d'entiers ou de réels / Complexe
	 */

	else if (((*s_objet_argument_1).type == CPL) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL)))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_colonnes;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
				.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_complexe16 *) (*s_objet_argument_1).objet))
				.partie_reelle == 0) && (((*((struct_complexe16 *)
				(*s_objet_argument_1).objet)).partie_imaginaire == 0)))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

			(*s_etat_processus).exception = d_ep_division_par_zero;
			return;
		}

		for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
				.objet))).nombre_lignes; i++)
		{
			if ((((struct_complexe16 **) (*((struct_matrice *)
					(*s_objet_resultat).objet)).tableau)[i] =
					malloc((*(((struct_matrice *)
					(*s_objet_resultat).objet))).nombre_colonnes *
					sizeof(struct_complexe16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
					.objet))).nombre_colonnes; j++)
			{
				if ((*s_objet_argument_2).type == MIN)
				{
					f77divisionic_(&(((integer8 **)
							(*((struct_matrice *) (*s_objet_argument_2).objet))
							.tableau)[i][j]), &(*((struct_complexe16 *)
							(*s_objet_argument_1).objet)),
							&((struct_complexe16 **) (*((struct_matrice *)
							(*s_objet_resultat).objet)).tableau)[i][j]);
				}
				else
				{
					f77divisionrc_(&(((real8 **)
							(*((struct_matrice *) (*s_objet_argument_2).objet))
							.tableau)[i][j]), &(*((struct_complexe16 *)
							(*s_objet_argument_1).objet)),
							&((struct_complexe16 **) (*((struct_matrice *)
							(*s_objet_resultat).objet)).tableau)[i][j]);
				}
			}
		}
	}

	/*
	 * Matrice de complexes / Entier, réel
	 */

	else if ((((*s_objet_argument_1).type == INT) ||
			((*s_objet_argument_1).type == REL)) &&
			((*s_objet_argument_2).type == MCX))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, MCX)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_colonnes;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
				.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*s_objet_argument_1).type == INT)
		{
			diviseur_reel = (real8) (*((integer8 *)
					(*s_objet_argument_1).objet));
		}
		else
		{
			diviseur_reel = (*((real8 *) (*s_objet_argument_1).objet));
		}

		if (diviseur_reel == 0)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

			(*s_etat_processus).exception = d_ep_division_par_zero;
			return;
		}

		for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
				.objet))).nombre_lignes; i++)
		{
			if ((((struct_complexe16 **) (*((struct_matrice *)
					(*s_objet_resultat).objet)).tableau)[i] =
					malloc((*(((struct_matrice *)
					(*s_objet_resultat).objet))).nombre_colonnes *
					sizeof(struct_complexe16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
					.objet))).nombre_colonnes; j++)
			{
				if ((*s_objet_argument_1).type == INT)
				{
					f77divisionci_(&(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_argument_2).objet))
							.tableau)[i][j]), &((*((integer8 *)
							(*s_objet_argument_1).objet))),
							&(((struct_complexe16 **) (*((struct_matrice *)
							(*s_objet_resultat).objet)).tableau)[i][j]));
				}
				else
				{
					f77divisioncr_(&(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_argument_2).objet))
							.tableau)[i][j]), &((*((real8 *)
							(*s_objet_argument_1).objet))),
							&(((struct_complexe16 **) (*((struct_matrice *)
							(*s_objet_resultat).objet)).tableau)[i][j]));
				}
			}
		}
	}

	/*
	 * Matrice de complexes / Complexe
	 */

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

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*((struct_matrice *) (*s_objet_argument_2).objet))
				.nombre_colonnes;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
				.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if (((*((struct_complexe16 *) (*s_objet_argument_1).objet))
				.partie_reelle == 0) && ((*((struct_complexe16 *)
				(*s_objet_argument_1).objet)).partie_imaginaire == 0))
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

			(*s_etat_processus).exception = d_ep_division_par_zero;
			return;
		}

		for(i = 0; i < (*(((struct_matrice *) (*s_objet_resultat)
				.objet))).nombre_lignes; i++)
		{
			if ((((struct_complexe16 **) (*((struct_matrice *)
					(*s_objet_resultat).objet)).tableau)[i] =
					malloc((*(((struct_matrice *)
					(*s_objet_resultat).objet))).nombre_colonnes *
					sizeof(struct_complexe16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*(((struct_matrice *) (*s_objet_resultat)
					.objet))).nombre_colonnes; j++)
			{
				f77divisioncc_(&(((struct_complexe16 **)
						(*((struct_matrice *) (*s_objet_argument_2).objet))
						.tableau)[i][j]), &((*((struct_complexe16 *)
						(*s_objet_argument_1).objet))),
						&(((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i][j]));
			}
		}
	}

/*
--------------------------------------------------------------------------------
  Division mettant en oeuvre une inversion de matrice
--------------------------------------------------------------------------------
*/
	/*
	 * Vecteur d'entiers ou de réels / Matrice d'entiers ou de réels
	 */

	else if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL)) &&
			(((*s_objet_argument_2).type == VIN) ||
			((*s_objet_argument_2).type == VRL)))
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			(*s_objet_argument_1).type = MRL;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes != (*(((struct_vecteur *)
				(*s_objet_argument_2).objet))).taille)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				(*(((struct_vecteur *) (*s_objet_argument_2)
				.objet))).taille;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille * sizeof(real8))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

		for(i = 0; i < (*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille; i++)
		{
			((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
			   	.tableau)[i] = 0;

			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_colonnes; j++)
			{
				if ((*s_objet_argument_2).type == VIN)
				{
					((real8 *) (*((struct_vecteur *)
							(*s_objet_resultat).objet))
							.tableau)[i] += ((real8 **) (*((struct_matrice *)
							(*s_objet_argument_1).objet)).tableau)[i][j] *
							((integer8 *) (*((struct_vecteur *)
							(*s_objet_argument_2).objet)).tableau)[j];
				}
				else
				{
					((real8 *) (*((struct_vecteur *)
							(*s_objet_resultat).objet))
							.tableau)[i] += ((real8 **) (*((struct_matrice *)
							(*s_objet_argument_1).objet)).tableau)[i][j] *
							((real8 *) (*((struct_vecteur *)
							(*s_objet_argument_2).objet)).tableau)[j];
				}
			}
		}
	}

	/*
	 * Vecteur d'entiers ou de réels / Matrice de complexes
	 */

	else if (((*s_objet_argument_1).type == MCX) &&
			(((*s_objet_argument_2).type == VIN) ||
			((*s_objet_argument_2).type == VRL)))
	{
		if ((*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes != (*(((struct_vecteur *)
				(*s_objet_argument_2).objet))).taille)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).type = 'C';
		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				(*(((struct_vecteur *) (*s_objet_argument_2)
				.objet))).taille;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille * sizeof(struct_complexe16)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

		for(i = 0; i < (*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille; i++)
		{
			(((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_resultat).objet)).tableau)[i]).partie_reelle = 0;
			(((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_resultat).objet)).tableau)[i]).partie_imaginaire
			   		= 0;

			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_colonnes; j++)
			{
				if ((*s_objet_argument_2).type == VIN)
				{
					f77multiplicationci_(&(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][j]), &(((integer8 *)
							(*((struct_vecteur *) (*s_objet_argument_2).objet))
							.tableau)[j]), &accumulateur);

					f77additioncc_(&(((struct_complexe16 *)
							(*((struct_vecteur *) (*s_objet_resultat).objet))
							.tableau)[i]), &accumulateur,
							&(((struct_complexe16 *)
							(*((struct_vecteur *) (*s_objet_resultat).objet))
							.tableau)[i]));
				}
				else
				{
					f77multiplicationcr_(&(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][j]), &(((real8 *)
							(*((struct_vecteur *) (*s_objet_argument_2).objet))
							.tableau)[j]), &accumulateur);

					f77additioncc_(&(((struct_complexe16 *)
							(*((struct_vecteur *) (*s_objet_resultat).objet))
							.tableau)[i]), &accumulateur,
							&(((struct_complexe16 *)
							(*((struct_vecteur *) (*s_objet_resultat).objet))
							.tableau)[i]));
				}
			}
		}
	}

	/*
	 * Vecteur de complexes / Matrice de complexes
	 */

	else if (((*s_objet_argument_1).type == MCX) &&
			((*s_objet_argument_2).type == VCX))
	{
		if ((*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes != (*(((struct_vecteur *)
				(*s_objet_argument_2).objet))).taille)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				(*(((struct_vecteur *) (*s_objet_argument_2)
				.objet))).taille;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille * sizeof(struct_complexe16)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

		for(i = 0; i < (*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille; i++)
		{
			(((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_resultat).objet)).tableau)[i]).partie_reelle = 0;
			(((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_resultat).objet)).tableau)[i]).partie_imaginaire
			   		= 0;

			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_colonnes; j++)
			{
				f77multiplicationcc_(&(((struct_complexe16 **)
						(*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau)[i][j]), &(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[j]), &accumulateur);

				f77additioncc_(&(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_resultat).objet))
						.tableau)[i]), &accumulateur,
						&(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_resultat).objet))
						.tableau)[i]));
			}
		}
	}

	/*
	 * Vecteur de complexes / Matrice d'entiers ou de réels
	 */

	else if (((*s_objet_argument_2).type == VCX) &&
			(((*s_objet_argument_1).type == MRL) ||
			((*s_objet_argument_1).type == MIN)))
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			(*s_objet_argument_1).type = MRL;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes != (*(((struct_vecteur *)
				(*s_objet_argument_2).objet))).taille)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_vecteur *) (*s_objet_resultat).objet)).taille =
				(*(((struct_vecteur *) (*s_objet_argument_2)
				.objet))).taille;

		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille * sizeof(struct_complexe16)))
				== NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

		for(i = 0; i < (*((struct_vecteur *)
				(*s_objet_resultat).objet)).taille; i++)
		{
			(((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_resultat).objet)).tableau)[i]).partie_reelle = 0;
			(((struct_complexe16 *) (*((struct_vecteur *)
					(*s_objet_resultat).objet)).tableau)[i]).partie_imaginaire
			   		= 0;

			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument_1).objet))
					.nombre_colonnes; j++)
			{
				f77multiplicationcr_(&(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_argument_2).objet))
						.tableau)[j]), &(((real8 **)
						(*((struct_matrice *) (*s_objet_argument_1).objet))
						.tableau)[i][j]), &accumulateur);

				f77additioncc_(&(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_resultat).objet))
						.tableau)[i]), &accumulateur,
						&(((struct_complexe16 *)
						(*((struct_vecteur *) (*s_objet_resultat).objet))
						.tableau)[i]));
			}
		}
	}
	
	/*
	 * Matrice d'entiers ou de réels / Matrice d'entiers ou de réels
	 */

	else if ((((*s_objet_argument_1).type == MIN) ||
			((*s_objet_argument_1).type == MRL)) &&
			(((*s_objet_argument_2).type == MIN) ||
			((*s_objet_argument_2).type == MRL)))
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			(*s_objet_argument_1).type = MRL;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes != (*(((struct_matrice *)
				(*s_objet_argument_2).objet))).nombre_lignes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_colonnes;

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

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

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

			for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes; j++)
			{
				((real8 **) (*((struct_matrice *) (*s_objet_resultat).objet))
						.tableau)[i][j] = 0;

				for(k = 0; k < (*((struct_matrice *) (*s_objet_argument_2)
						.objet)).nombre_lignes; k++)
				{
					if ((*s_objet_argument_2).type == MIN)
					{
						((real8 **) (*((struct_matrice *)
								(*s_objet_resultat).objet))
								.tableau)[i][j] += ((real8 **)
								(*((struct_matrice *)
								(*s_objet_argument_1).objet)).tableau)[i][k] *
								((integer8 **) (*((struct_matrice *)
								(*s_objet_argument_2).objet)).tableau)[k][j];
					}
					else
					{
						((real8 **) (*((struct_matrice *)
								(*s_objet_resultat).objet))
								.tableau)[i][j] += ((real8 **)
								(*((struct_matrice *)
								(*s_objet_argument_1).objet)).tableau)[i][k] *
								((real8 **) (*((struct_matrice *)
								(*s_objet_argument_2).objet)).tableau)[k][j];
					}
				}
			}
		}
	}

	/*
	 * Matrice d'entiers ou de réels / Matrice de complexes
	 */

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

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

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

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_colonnes;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_matrice *)
				(*s_objet_resultat).objet)).nombre_lignes *
				sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus, 
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

		for(i = 0; i < (*((struct_matrice *)
				(*s_objet_resultat).objet)).nombre_lignes; i++)
		{
			if ((((*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]
					= malloc((*((struct_matrice *)
					(*s_objet_resultat).objet)).nombre_colonnes *
					sizeof(struct_complexe16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes; j++)
			{
				(((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i][j])
						.partie_reelle = 0;
				(((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i][j])
						.partie_imaginaire = 0;

				for(k = 0; k < (*((struct_matrice *) (*s_objet_argument_2)
						.objet)).nombre_lignes; k++)
				{
					if ((*s_objet_argument_2).type == MIN)
					{
						f77multiplicationci_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][k]), &(((integer8 **)
								(*((struct_matrice *) (*s_objet_argument_2)
								.objet)).tableau)[k][j]), &accumulateur);

						f77additioncc_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_resultat)
								.objet)).tableau)[i][j]), &accumulateur,
								&(((struct_complexe16 **) (*((struct_matrice *)
								(*s_objet_resultat).objet)).tableau)[i][j]));
					}
					else
					{
						f77multiplicationcr_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][k]), &(((real8 **)
								(*((struct_matrice *) (*s_objet_argument_2)
								.objet)).tableau)[k][j]), &accumulateur);

						f77additioncc_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_resultat)
								.objet)).tableau)[i][j]), &accumulateur,
								&(((struct_complexe16 **) (*((struct_matrice *)
								(*s_objet_resultat).objet)).tableau)[i][j]));
					}
				}
			}
		}
	}

	/*
	 * Matrice de complexes / Matrice de complexes
	 */

	else if (((*s_objet_argument_1).type == MCX) &&
			((*s_objet_argument_2).type == MCX))
	{
		if ((*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes != (*(((struct_matrice *)
				(*s_objet_argument_2).objet))).nombre_lignes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_colonnes;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_matrice *)
				(*s_objet_resultat).objet)).nombre_lignes *
				sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

		for(i = 0; i < (*((struct_matrice *)
				(*s_objet_resultat).objet)).nombre_lignes; i++)
		{
			if ((((*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]
					= malloc((*((struct_matrice *)
					(*s_objet_resultat).objet)).nombre_colonnes *
					sizeof(struct_complexe16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}

			for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes; j++)
			{
				(((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i][j])
						.partie_reelle = 0;
				(((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i][j])
						.partie_imaginaire = 0;

				for(k = 0; k < (*((struct_matrice *) (*s_objet_argument_2)
						.objet)).nombre_lignes; k++)
				{
					f77multiplicationcc_(&(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_argument_1).objet))
							.tableau)[i][k]), &(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_argument_2).objet))
							.tableau)[k][j]), &accumulateur);

					f77additioncc_(&(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_resultat).objet))
							.tableau)[i][j]), &accumulateur,
							&(((struct_complexe16 **)
							(*((struct_matrice *) (*s_objet_resultat).objet))
							.tableau)[i][j]));
				}
			}
		}
	}

	/*
	 * Matrice de complexes / Matrice d'entiers ou de réels
	 */

	else if (((*s_objet_argument_2).type == MCX) &&
			(((*s_objet_argument_1).type == MRL) ||
			((*s_objet_argument_1).type == MIN)))
	{
		if ((*s_objet_argument_1).type == MIN)
		{
			(*s_objet_argument_1).type = MRL;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes != (*(((struct_matrice *)
				(*s_objet_argument_2).objet))).nombre_lignes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);

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

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

		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_lignes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_lignes;
		(*((struct_matrice *) (*s_objet_resultat).objet)).nombre_colonnes =
				(*(((struct_matrice *) (*s_objet_argument_2)
				.objet))).nombre_colonnes;

		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
				malloc((*((struct_matrice *)
				(*s_objet_resultat).objet)).nombre_colonnes *
				sizeof(struct_complexe16))) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*(((struct_matrice *) (*s_objet_argument_1).objet))).nombre_lignes
				!= (*(((struct_matrice *) (*s_objet_argument_1).objet)))
				.nombre_colonnes)
		{
			liberation(s_etat_processus, s_objet_argument_1);
			liberation(s_etat_processus, s_objet_argument_2);
			liberation(s_etat_processus, s_objet_resultat);

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

		inversion_matrice(s_etat_processus,
				(struct_matrice *) (*s_objet_argument_1).objet);

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

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

		for(i = 0; i < (*((struct_matrice *)
				(*s_objet_resultat).objet)).nombre_lignes; i++)
		{
			if ((((*((struct_matrice *) (*s_objet_resultat).objet)).tableau)[i]
					= malloc((*((struct_matrice *)
					(*s_objet_resultat).objet)).nombre_colonnes *
					sizeof(struct_complexe16))) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return;
			}
			
			for(j = 0; j < (*((struct_matrice *) (*s_objet_resultat).objet))
					.nombre_colonnes; j++)
			{
				(((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i][j])
						.partie_reelle = 0;
				(((struct_complexe16 **) (*((struct_matrice *)
						(*s_objet_resultat).objet)).tableau)[i][j])
						.partie_imaginaire = 0;

				for(k = 0; k < (*((struct_matrice *) (*s_objet_argument_2)
						.objet)).nombre_lignes; k++)
				{
					if ((*s_objet_argument_1).type == MIN)
					{
						f77multiplicationci_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_argument_2)
								.objet)).tableau)[k][j]), &(((integer8 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][k]), &accumulateur);

						f77additioncc_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_resultat)
								.objet)).tableau)[i][j]), &accumulateur,
								&(((struct_complexe16 **) (*((struct_matrice *)
								(*s_objet_resultat).objet))
								.tableau)[i][j]));
					}
					else
					{
						f77multiplicationcr_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_argument_2)
								.objet)).tableau)[k][j]), &(((real8 **)
								(*((struct_matrice *) (*s_objet_argument_1)
								.objet)).tableau)[i][k]), &accumulateur);

						f77additioncc_(&(((struct_complexe16 **)
								(*((struct_matrice *) (*s_objet_resultat)
								.objet)).tableau)[i][j]), &accumulateur,
								&(((struct_complexe16 **) (*((struct_matrice *)
								(*s_objet_resultat).objet))
								.tableau)[i][j]));
					}
				}
			}
		}
	}
	
/*
--------------------------------------------------------------------------------
  Division mettant en oeuvre des binaires
--------------------------------------------------------------------------------
*/
	/*
	 * Binaire / Binaire
	 */

	else if (((*s_objet_argument_1).type == BIN) &&
			((*s_objet_argument_2).type == BIN))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		(*((logical8 *) (*s_objet_resultat).objet)) =
				(*((logical8 *) (*s_objet_argument_2).objet))
				/ (*((logical8 *) (*s_objet_argument_1).objet));
	}

	/*
	 * Binaire / Entier
	 */

	else if ((((*s_objet_argument_1).type == BIN) &&
			((*s_objet_argument_2).type == INT)) ||
			(((*s_objet_argument_1).type == INT) &&
			((*s_objet_argument_2).type == BIN)))
	{
		if ((s_objet_resultat = allocation(s_etat_processus, BIN)) == NULL)
		{
			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
			return;
		}

		if ((*s_objet_argument_1).type == BIN)
		{
			(*((logical8 *) (*s_objet_resultat).objet)) =
					(*((integer8 *) (*s_objet_argument_2).objet))
					/ (*((logical8 *) (*s_objet_argument_1).objet));
		}
		else
		{
			(*((logical8 *) (*s_objet_resultat).objet)) =
					(*((logical8 *) (*s_objet_argument_2).objet))
					/ (*((integer8 *) (*s_objet_argument_1).objet));
		}
	}

/*
--------------------------------------------------------------------------------
  Division impossible
--------------------------------------------------------------------------------
*/

	else
	{
		liberation(s_etat_processus, s_objet_argument_1);
		liberation(s_etat_processus, s_objet_argument_2);

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

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

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

	return;
}


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

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

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

		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("    DO\n");
		printf("        (expression 1)\n");
		printf("        EXIT\n");
		printf("        (expression 2)\n");
		printf("    UNTIL\n");
		printf("        (clause)\n");
		printf("    END\n\n");

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

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

	empilement_pile_systeme(s_etat_processus);

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

	(*(*s_etat_processus).l_base_pile_systeme).type_cloture = 'D';
	(*(*s_etat_processus).l_base_pile_systeme).clause = 'D';

	if ((*s_etat_processus).mode_execution_programme == 'Y')
	{
		(*(*s_etat_processus).l_base_pile_systeme).adresse_retour =
				(*s_etat_processus).position_courante;
	}
	else
	{
		if ((*s_etat_processus).expression_courante == NULL)
		{
			(*s_etat_processus).erreur_execution =
					d_ex_erreur_traitement_boucle;
			return;
		}

		(*(*s_etat_processus).l_base_pile_systeme).pointeur_objet_retour =
				(*s_etat_processus).expression_courante;
	}

	return;
}


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

void
instruction_default(struct_processus *s_etat_processus)
{
	logical1						drapeau_fin;
	logical1						erreur;

	unsigned char					*instruction_majuscule;
	unsigned char					*tampon;

	unsigned long					niveau;

	(*s_etat_processus).erreur_execution = d_ex;

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

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

		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 == 'C')
	{
		if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'C')
		{
			/*
			 * Au moins un cas CASE a été traité et l'on saute au END
			 * correspondant.
			 */

			tampon = (*s_etat_processus).instruction_courante;
			niveau = 0;

			do
			{
				if ((*s_etat_processus).mode_execution_programme == 'Y')
				{
					erreur = recherche_instruction_suivante(s_etat_processus);
				}
				else
				{
					erreur = d_absence_erreur;

					if ((*s_etat_processus).expression_courante != NULL)
					{
						while(((*(*(*s_etat_processus)
								.expression_courante).donnee).type != FCT)
								&& (erreur == d_absence_erreur))
						{
							if ((*s_etat_processus).expression_courante == NULL)
							{
								erreur = d_erreur;
							}
							else
							{
								(*s_etat_processus).expression_courante =
										(*(*s_etat_processus)
										.expression_courante).suivant;
							}
						}
					}
					else
					{
						erreur = d_erreur;
					}

					if (erreur == d_absence_erreur)
					{
						if (((*s_etat_processus).instruction_courante =
								malloc((strlen(
								(*((struct_fonction *) (*(*(*s_etat_processus)
								.expression_courante).donnee).objet))
								.nom_fonction) + 1) * sizeof(unsigned char)))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return;
						}

						strcpy((*s_etat_processus).instruction_courante,
								(*((struct_fonction *) (*(*(*s_etat_processus)
								.expression_courante).donnee).objet))
								.nom_fonction);
					}
				}

				if (erreur != d_absence_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;
				}

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

				if (niveau == 0)
				{
					if (strcmp(instruction_majuscule, "END") == 0)
					{
						if ((*s_etat_processus).mode_execution_programme == 'Y')
						{
							(*s_etat_processus).position_courante -= (strlen(
									instruction_majuscule) + 1);
						}
						else
						{
							instruction_end(s_etat_processus);
						}

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

				if (((*s_etat_processus).mode_execution_programme != 'Y') &&
						(drapeau_fin == d_faux))
				{
					(*s_etat_processus).expression_courante =
							(*(*s_etat_processus)
							.expression_courante).suivant;
				}
			} while(drapeau_fin == d_faux);

			(*s_etat_processus).instruction_courante = tampon;
		}
		else
		{
			if ((*(*s_etat_processus).l_base_pile_systeme).clause == 'F')
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_traitement_condition;
				return;
			}

			(*(*s_etat_processus).l_base_pile_systeme).clause = 'F';
		}
	}
	else
	{
		(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_condition;
		return;
	}

	return;
}

// vim: ts=4