rpl/src/instructions_m1.c - diff

Return to instructions_m1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_m1.c between versions 1.42 and 1.70

version 1.42, 2013/03/16 11:31:41	version 1.70, 2023/08/07 17:42:56
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.35
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2023 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 53 instruction_moins(struct_processus *s_et	Line 53 instruction_moins(struct_processus *s_et
struct_objet *s_objet_argument_2;	struct_objet *s_objet_argument_2;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long nombre_elements;	integer8 nombre_elements;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 184 instruction_moins(struct_processus *s_et	Line 184 instruction_moins(struct_processus *s_et
if ((*s_objet_argument_1).type == INT)	if ((*s_objet_argument_1).type == INT)
{	{
(((real8 ) (s_objet_resultat).objet)) = (((real8 *)	(((real8 ) (s_objet_resultat).objet)) = (((real8 *)
(s_objet_argument_2).objet)) - (((integer8 *)	(s_objet_argument_2).objet)) - ((real8) (((integer8 *)
(*s_objet_argument_1).objet));	(*s_objet_argument_1).objet)));
}	}
else	else
{	{
(((real8 ) (s_objet_resultat).objet)) = (((integer8 *)	(((real8 ) (s_objet_resultat).objet)) = ((real8) (((integer8 *)
(s_objet_argument_2).objet)) - (((real8 *)	(s_objet_argument_2).objet))) - (((real8 *)
(*s_objet_argument_1).objet));	(*s_objet_argument_1).objet));
}	}
}	}
Line 336 instruction_moins(struct_processus *s_et	Line 336 instruction_moins(struct_processus *s_et
(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(integer8))) == NULL)	.objet))).taille) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 364 instruction_moins(struct_processus *s_et	Line 364 instruction_moins(struct_processus *s_et
free((((struct_vecteur ) (*s_objet_argument_1).objet)).tableau);	free((((struct_vecteur ) (*s_objet_argument_1).objet)).tableau);

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 418 instruction_moins(struct_processus *s_et	Line 418 instruction_moins(struct_processus *s_et
(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 433 instruction_moins(struct_processus *s_et	Line 433 instruction_moins(struct_processus *s_et
((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))	((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))
.tableau)[i] = ((real8 ) (((struct_vecteur *)	.tableau)[i] = ((real8 ) (((struct_vecteur *)
(*s_objet_argument_2).objet)).tableau)[i]	(*s_objet_argument_2).objet)).tableau)[i]
- ((integer8 ) (((struct_vecteur *)	- ((real8) ((integer8 ) (((struct_vecteur *)
(*s_objet_argument_1).objet)).tableau)[i];	(*s_objet_argument_1).objet)).tableau)[i]);
}	}
else	else
{	{
((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))	((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))
.tableau)[i] = ((integer8 ) (((struct_vecteur *)	.tableau)[i] = ((real8) ((integer8 *)
(*s_objet_argument_2).objet)).tableau)[i]	(((struct_vecteur ) (*s_objet_argument_2).objet))
- ((real8 ) (((struct_vecteur *)	.tableau)[i]) - ((real8 ) (((struct_vecteur *)
(*s_objet_argument_1).objet)).tableau)[i];	(*s_objet_argument_1).objet)).tableau)[i];
}	}
}	}
Line 476 instruction_moins(struct_processus *s_et	Line 476 instruction_moins(struct_processus *s_et
(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 525 instruction_moins(struct_processus *s_et	Line 525 instruction_moins(struct_processus *s_et
(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 588 instruction_moins(struct_processus *s_et	Line 588 instruction_moins(struct_processus *s_et
(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 649 instruction_moins(struct_processus *s_et	Line 649 instruction_moins(struct_processus *s_et
(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_1).objet)).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 710 instruction_moins(struct_processus *s_et	Line 710 instruction_moins(struct_processus *s_et
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(integer8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 723 instruction_moins(struct_processus *s_et	Line 723 instruction_moins(struct_processus *s_et
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((integer8 *) (((struct_matrice ) (s_objet_resultat)	if ((((integer8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i] = malloc((*((	.objet)).tableau)[i] = malloc(((size_t) (*((
(struct_matrice ) (s_objet_resultat).objet)))	(struct_matrice ) (s_objet_resultat).objet)))
.nombre_colonnes * sizeof(integer8))) == NULL)	.nombre_colonnes) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 759 instruction_moins(struct_processus *s_et	Line 759 instruction_moins(struct_processus *s_et
(*s_objet_resultat).objet)).tableau)[i]);	(*s_objet_resultat).objet)).tableau)[i]);

if ((((real8 *) (((struct_matrice ) (s_objet_resultat)	if ((((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i] = malloc((*((	.objet)).tableau)[i] = malloc(((size_t) (*((
(struct_matrice ) (s_objet_resultat).objet)))	(struct_matrice ) (s_objet_resultat).objet)))
.nombre_colonnes * sizeof(real8))) == NULL)	.nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 821 instruction_moins(struct_processus *s_et	Line 821 instruction_moins(struct_processus *s_et
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(real8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 832 instruction_moins(struct_processus *s_et	Line 832 instruction_moins(struct_processus *s_et
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((real8 *) (((struct_matrice ) (s_objet_resultat)	if ((((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i] = malloc((*((	.objet)).tableau)[i] = malloc(((size_t) (*((
(struct_matrice ) (s_objet_resultat).objet)))	(struct_matrice ) (s_objet_resultat).objet)))
.nombre_colonnes * sizeof(real8))) == NULL)	.nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 848 instruction_moins(struct_processus *s_et	Line 848 instruction_moins(struct_processus *s_et
((real8 *) (((struct_matrice ) (s_objet_resultat)	((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i][j] = ((real8 **)	.objet)).tableau)[i][j] = ((real8 **)
(((struct_matrice ) (*s_objet_argument_2).objet))	(((struct_matrice ) (*s_objet_argument_2).objet))
.tableau)[i][j] - ((integer8 **)	.tableau)[i][j] - ((real8) ((integer8 **)
(((struct_matrice ) (*s_objet_argument_1).objet))	(((struct_matrice ) (*s_objet_argument_1).objet))
.tableau)[i][j];	.tableau)[i][j]);
}	}
else	else
{	{
((real8 *) (((struct_matrice ) (s_objet_resultat)	((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i][j] = ((integer8 **)	.objet)).tableau)[i][j] = ((real8) ((integer8 **)
(((struct_matrice ) (*s_objet_argument_2)	(((struct_matrice ) (*s_objet_argument_2)
.objet)).tableau)[i][j] - ((real8 **)	.objet)).tableau)[i][j]) - ((real8 **)
(((struct_matrice ) (*s_objet_argument_1).objet))	(((struct_matrice ) (*s_objet_argument_1).objet))
.tableau)[i][j];	.tableau)[i][j];
}	}
Line 902 instruction_moins(struct_processus *s_et	Line 902 instruction_moins(struct_processus *s_et
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(real8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 913 instruction_moins(struct_processus *s_et	Line 913 instruction_moins(struct_processus *s_et
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((real8 *) (((struct_matrice ) (s_objet_resultat)	if ((((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i] = malloc((*((	.objet)).tableau)[i] = malloc(((size_t) (*((
(struct_matrice ) (s_objet_resultat).objet)))	(struct_matrice ) (s_objet_resultat).objet)))
.nombre_colonnes * sizeof(real8))) == NULL)	.nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 972 instruction_moins(struct_processus *s_et	Line 972 instruction_moins(struct_processus *s_et
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 983 instruction_moins(struct_processus *s_et	Line 984 instruction_moins(struct_processus *s_et
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(s_objet_resultat).objet)).tableau)[i] = malloc((((	(*s_objet_resultat).objet)).tableau)[i] = malloc(
(struct_matrice ) (s_objet_resultat).objet)))	((size_t) ((((struct_matrice ) (*s_objet_resultat)
.nombre_colonnes * sizeof(struct_complexe16))) == NULL)	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1056 instruction_moins(struct_processus *s_et	Line 1058 instruction_moins(struct_processus *s_et
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1067 instruction_moins(struct_processus *s_et	Line 1070 instruction_moins(struct_processus *s_et
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(s_objet_resultat).objet)).tableau)[i] = malloc((((	(*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t)
(struct_matrice ) (s_objet_resultat).objet)))	((((struct_matrice ) (*s_objet_resultat).objet)))
.nombre_colonnes * sizeof(struct_complexe16))) == NULL)	.nombre_colonnes) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1138 instruction_moins(struct_processus *s_et	Line 1141 instruction_moins(struct_processus *s_et
.nombre_colonnes;	.nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1149 instruction_moins(struct_processus *s_et	Line 1153 instruction_moins(struct_processus *s_et
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(s_objet_resultat).objet)).tableau)[i] = malloc((((	(*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t)
(struct_matrice ) (s_objet_resultat).objet)))	((((struct_matrice ) (*s_objet_resultat).objet)))
.nombre_colonnes * sizeof(struct_complexe16))) == NULL)	.nombre_colonnes) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 1214 instruction_moins(struct_processus *s_et	Line 1218 instruction_moins(struct_processus *s_et
if ((*s_objet_argument_1).type == BIN)	if ((*s_objet_argument_1).type == BIN)
{	{
(((logical8 ) (*s_objet_resultat).objet)) =	(((logical8 ) (*s_objet_resultat).objet)) =
(((integer8 ) (*s_objet_argument_2).objet))	((logical8) (((integer8 ) (*s_objet_argument_2).objet)))
- (((logical8 ) (*s_objet_argument_1).objet));	- (((logical8 ) (*s_objet_argument_1).objet));
}	}
else	else
{	{
(((logical8 ) (*s_objet_resultat).objet)) =	(((logical8 ) (*s_objet_resultat).objet)) =
(((logical8 ) (*s_objet_argument_2).objet))	(((logical8 ) (*s_objet_argument_2).objet))
- (((integer8 ) (*s_objet_argument_1).objet));	- ((logical8) (((integer8 ) (*s_objet_argument_1)
	.objet)));
}	}
}	}

Line 1933 instruction_multiplication(struct_proces	Line 1938 instruction_multiplication(struct_proces
struct_objet *s_objet_argument_2;	struct_objet *s_objet_argument_2;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

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

void *accumulateur;	void *accumulateur;

Line 2083 instruction_multiplication(struct_proces	Line 2088 instruction_multiplication(struct_proces
if ((*s_objet_argument_1).type == INT)	if ((*s_objet_argument_1).type == INT)
{	{
(((real8 ) (s_objet_resultat).objet)) = (((real8 *)	(((real8 ) (s_objet_resultat).objet)) = (((real8 *)
(s_objet_argument_2).objet)) (((integer8 )	(s_objet_argument_2).objet)) ((real8) (((integer8 )
(*s_objet_argument_1).objet));	(*s_objet_argument_1).objet)));
}	}
else	else
{	{
(((real8 ) (s_objet_resultat).objet)) = (((integer8 *)	(((real8 ) (s_objet_resultat).objet)) = ((real8) (((integer8 *)
(s_objet_argument_2).objet)) (((real8 )	(s_objet_argument_2).objet))) (((real8 )
(*s_objet_argument_1).objet));	(*s_objet_argument_1).objet));
}	}
}	}
Line 2234 instruction_multiplication(struct_proces	Line 2239 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(integer8))) == NULL)	.objet))).taille) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2276 instruction_multiplication(struct_proces	Line 2281 instruction_multiplication(struct_proces
(((struct_vecteur ) (*s_objet_resultat).objet)).type = 'R';	(((struct_vecteur ) (*s_objet_resultat).objet)).type = 'R';

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2334 instruction_multiplication(struct_proces	Line 2339 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2347 instruction_multiplication(struct_proces	Line 2352 instruction_multiplication(struct_proces
if ((*s_objet_argument_1).type == VRL)	if ((*s_objet_argument_1).type == VRL)
{	{
((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))	((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))
.tableau)[i] = (((integer8 ) (*s_objet_argument_2)	.tableau)[i] = ((real8) (((integer8 )
.objet)) * ((real8 ) (((struct_vecteur *)	(s_objet_argument_2).objet))) ((real8 *)
(*s_objet_argument_1).objet)).tableau)[i];	(((struct_vecteur ) (*s_objet_argument_1).objet))
	.tableau)[i];
}	}
else	else
{	{
((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))	((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))
.tableau)[i] = (((integer8 ) (*s_objet_argument_1)	.tableau)[i] = ((real8) (((integer8 )
.objet)) * ((real8 ) (((struct_vecteur *)	(s_objet_argument_1).objet))) ((real8 *)
(*s_objet_argument_2).objet)).tableau)[i];	(((struct_vecteur ) (*s_objet_argument_2).objet))
	.tableau)[i];
}	}
}	}
}	}
Line 2389 instruction_multiplication(struct_proces	Line 2396 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2448 instruction_multiplication(struct_proces	Line 2455 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2462 instruction_multiplication(struct_proces	Line 2469 instruction_multiplication(struct_proces
{	{
((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))	((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))
.tableau)[i] = (((real8 ) (*s_objet_argument_2)	.tableau)[i] = (((real8 ) (*s_objet_argument_2)
.objet)) * ((integer8 ) (((struct_vecteur *)	.objet)) * ((real8) ((integer8 ) (((struct_vecteur *)
(*s_objet_argument_1).objet)).tableau)[i];	(*s_objet_argument_1).objet)).tableau)[i]);
}	}
else	else
{	{
((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))	((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))
.tableau)[i] = (((real8 ) (*s_objet_argument_1)	.tableau)[i] = (((real8 ) (*s_objet_argument_1)
.objet)) * ((integer8 ) (((struct_vecteur *)	.objet)) * ((real8) ((integer8 ) (((struct_vecteur *)
(*s_objet_argument_2).objet)).tableau)[i];	(*s_objet_argument_2).objet)).tableau)[i]);
}	}
}	}
}	}
Line 2503 instruction_multiplication(struct_proces	Line 2510 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(real8))) == NULL)	.objet))).taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2558 instruction_multiplication(struct_proces	Line 2565 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2617 instruction_multiplication(struct_proces	Line 2624 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2676 instruction_multiplication(struct_proces	Line 2683 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2735 instruction_multiplication(struct_proces	Line 2742 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_vecteur ) (*s_objet_resultat)	malloc(((size_t) ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille * sizeof(struct_complexe16))) == NULL)	.objet))).taille) * sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2809 instruction_multiplication(struct_proces	Line 2816 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(integer8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2822 instruction_multiplication(struct_proces	Line 2829 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(integer8))) == NULL)	.objet))).nombre_colonnes) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2871 instruction_multiplication(struct_proces	Line 2878 instruction_multiplication(struct_proces
(*s_objet_resultat).objet)).tableau)[i]);	(*s_objet_resultat).objet)).tableau)[i]);

if (((((struct_matrice ) (*s_objet_resultat).objet))	if (((((struct_matrice ) (*s_objet_resultat).objet))
.tableau[i] = malloc(((((struct_matrice )	.tableau[i] = malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2942 instruction_multiplication(struct_proces	Line 2949 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(real8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2953 instruction_multiplication(struct_proces	Line 2960 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(real8))) == NULL)	.objet))).nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 2967 instruction_multiplication(struct_proces	Line 2974 instruction_multiplication(struct_proces
{	{
((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i][j] =	(*s_objet_resultat).objet)).tableau)[i][j] =
(((integer8 ) (*s_objet_argument_2)	((real8) (((integer8 ) (*s_objet_argument_2)
.objet)) * ((real8 *) (((struct_matrice *)	.objet))) * ((real8 *) (((struct_matrice *)
(*s_objet_argument_1).objet)).tableau)[i][j];	(*s_objet_argument_1).objet)).tableau)[i][j];
}	}
else	else
{	{
((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i][j] =	(*s_objet_resultat).objet)).tableau)[i][j] =
(((integer8 ) (*s_objet_argument_1)	((real8) (((integer8 ) (*s_objet_argument_1)
.objet)) * ((real8 *) (((struct_matrice *)	.objet))) * ((real8 *) (((struct_matrice *)
(*s_objet_argument_2).objet)).tableau)[i][j];	(*s_objet_argument_2).objet)).tableau)[i][j];
}	}
}	}
Line 3019 instruction_multiplication(struct_proces	Line 3026 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3030 instruction_multiplication(struct_proces	Line 3038 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3099 instruction_multiplication(struct_proces	Line 3107 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(real8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3110 instruction_multiplication(struct_proces	Line 3118 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(real8))) == NULL)	.objet))).nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3125 instruction_multiplication(struct_proces	Line 3133 instruction_multiplication(struct_proces
((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i][j] =	(*s_objet_resultat).objet)).tableau)[i][j] =
(((real8 ) (*s_objet_argument_2)	(((real8 ) (*s_objet_argument_2)
.objet)) * ((integer8 *) (((struct_matrice *)	.objet)) * ((real8) ((integer8 *) (((struct_matrice *)
(*s_objet_argument_1).objet)).tableau)[i][j];	(*s_objet_argument_1).objet)).tableau)[i][j]);
}	}
else	else
{	{
((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i][j] =	(*s_objet_resultat).objet)).tableau)[i][j] =
(((real8 ) (*s_objet_argument_1)	(((real8 ) (*s_objet_argument_1)
.objet)) * ((integer8 *) (((struct_matrice *)	.objet)) * ((real8) ((integer8 *) (((struct_matrice *)
(*s_objet_argument_2).objet)).tableau)[i][j];	(*s_objet_argument_2).objet)).tableau)[i][j]);
}	}
}	}
}	}
Line 3176 instruction_multiplication(struct_proces	Line 3184 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(real8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3187 instruction_multiplication(struct_proces	Line 3195 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(real8))) == NULL)	.objet))).nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3253 instruction_multiplication(struct_proces	Line 3261 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3264 instruction_multiplication(struct_proces	Line 3273 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3333 instruction_multiplication(struct_proces	Line 3342 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3344 instruction_multiplication(struct_proces	Line 3354 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3413 instruction_multiplication(struct_proces	Line 3423 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3424 instruction_multiplication(struct_proces	Line 3435 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3493 instruction_multiplication(struct_proces	Line 3504 instruction_multiplication(struct_proces
}	}

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3504 instruction_multiplication(struct_proces	Line 3516 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3573 instruction_multiplication(struct_proces	Line 3585 instruction_multiplication(struct_proces
}	}

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_argument_2)	malloc(((size_t) ((((struct_matrice ) (*s_objet_argument_2)
.objet))).nombre_lignes * sizeof(integer8))) == NULL)	.objet))).nombre_lignes) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3618 instruction_multiplication(struct_proces	Line 3630 instruction_multiplication(struct_proces
(((struct_vecteur ) (*s_objet_resultat).objet)).type = 'R';	(((struct_vecteur ) (*s_objet_resultat).objet)).type = 'R';

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_argument_2)	malloc(((size_t) ((((struct_matrice )
.objet))).nombre_lignes * sizeof(real8))) == NULL)	(s_objet_argument_2).objet))).nombre_lignes)
	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3678 instruction_multiplication(struct_proces	Line 3691 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3699 instruction_multiplication(struct_proces	Line 3712 instruction_multiplication(struct_proces
for(k = 0; k < ((((struct_matrice ) (*s_objet_argument_2)	for(k = 0; k < ((((struct_matrice ) (*s_objet_argument_2)
.objet))).nombre_colonnes; k++)	.objet))).nombre_colonnes; k++)
{	{
((real8 ) accumulateur)[k] = (((integer8 *)	((real8 ) accumulateur)[k] = ((real8) ((integer8 *)
(((struct_matrice ) (*s_objet_argument_2).objet))	(((struct_matrice ) (*s_objet_argument_2).objet))
.tableau)[i][k] * ((real8 ) (((struct_vecteur *)	.tableau)[i][k]) * ((real8 ) (((struct_vecteur *)
(*s_objet_argument_1).objet)).tableau)[k]);	(*s_objet_argument_1).objet)).tableau)[k];
}	}

((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))	((real8 ) (((struct_vecteur ) (s_objet_resultat).objet))
Line 3751 instruction_multiplication(struct_proces	Line 3764 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3825 instruction_multiplication(struct_proces	Line 3838 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3846 instruction_multiplication(struct_proces	Line 3859 instruction_multiplication(struct_proces
for(k = 0; k < ((((struct_matrice ) (*s_objet_argument_2)	for(k = 0; k < ((((struct_matrice ) (*s_objet_argument_2)
.objet))).nombre_colonnes; k++)	.objet))).nombre_colonnes; k++)
{	{
((real8 ) accumulateur)[k] = (((real8 ) (((struct_matrice *)	((real8 ) accumulateur)[k] = ((real8 ) (((struct_matrice *)
(s_objet_argument_2).objet)).tableau)[i][k]	(s_objet_argument_2).objet)).tableau)[i][k]
((integer8 ) (((struct_vecteur *)	((real8) ((integer8 ) (((struct_vecteur *)
(*s_objet_argument_1).objet)).tableau)[k]);	(*s_objet_argument_1).objet)).tableau)[k]);
}	}

Line 3898 instruction_multiplication(struct_proces	Line 3911 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3971 instruction_multiplication(struct_proces	Line 3984 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4045 instruction_multiplication(struct_proces	Line 4058 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4119 instruction_multiplication(struct_proces	Line 4132 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4193 instruction_multiplication(struct_proces	Line 4206 instruction_multiplication(struct_proces
}	}

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4274 instruction_multiplication(struct_proces	Line 4287 instruction_multiplication(struct_proces
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(integer8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 4287 instruction_multiplication(struct_proces	Line 4300 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(integer8))) == NULL)	.objet))).nombre_colonnes) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 4330 instruction_multiplication(struct_proces	Line 4343 instruction_multiplication(struct_proces
(*s_objet_resultat).type = MRL;	(*s_objet_resultat).type = MRL;
(((struct_matrice ) (*s_objet_resultat).objet)).type = 'R';	(((struct_matrice ) (*s_objet_resultat).objet)).type = 'R';

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4345 instruction_multiplication(struct_proces	Line 4358 instruction_multiplication(struct_proces
(*s_objet_resultat).objet)).tableau)[i]);	(*s_objet_resultat).objet)).tableau)[i]);

if (((((struct_matrice ) (*s_objet_resultat).objet))	if (((((struct_matrice ) (*s_objet_resultat).objet))
.tableau[i] = malloc(((((struct_matrice )	.tableau[i] = malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 4424 instruction_multiplication(struct_proces	Line 4437 instruction_multiplication(struct_proces
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4443 instruction_multiplication(struct_proces	Line 4456 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(real8))) == NULL)	.objet))).nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 4459 instruction_multiplication(struct_proces	Line 4472 instruction_multiplication(struct_proces
if ((*s_objet_argument_1).type == MRL)	if ((*s_objet_argument_1).type == MRL)
{	{
((real8 *) accumulateur)[k] =	((real8 *) accumulateur)[k] =
(((integer8 *) (((struct_matrice *)	((real8) ((integer8 *) (((struct_matrice *)
(s_objet_argument_2).objet)).tableau)[i][k]	(s_objet_argument_2).objet)).tableau)[i][k])
((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
(*s_objet_argument_1).objet)).tableau)[k][j]);	(*s_objet_argument_1).objet)).tableau)[k][j];
}	}
else	else
{	{
((real8 *) accumulateur)[k] =	((real8 *) accumulateur)[k] =
(((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
(s_objet_argument_2).objet)).tableau)[i][k]	(s_objet_argument_2).objet)).tableau)[i][k]
((integer8 *) (((struct_matrice *)	((real8) ((integer8 *) (((struct_matrice *)
(*s_objet_argument_1).objet)).tableau)[k][j]);	(*s_objet_argument_1).objet)).tableau)[k][j]);
}	}
}	}
Line 4527 instruction_multiplication(struct_proces	Line 4540 instruction_multiplication(struct_proces
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4546 instruction_multiplication(struct_proces	Line 4560 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4631 instruction_multiplication(struct_proces	Line 4645 instruction_multiplication(struct_proces
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4650 instruction_multiplication(struct_proces	Line 4664 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(real8))) == NULL)	.objet))).nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 4723 instruction_multiplication(struct_proces	Line 4737 instruction_multiplication(struct_proces
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4742 instruction_multiplication(struct_proces	Line 4757 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4827 instruction_multiplication(struct_proces	Line 4842 instruction_multiplication(struct_proces
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

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

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument_2).objet))).nombre_colonnes	(s_objet_argument_2).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4846 instruction_multiplication(struct_proces	Line 4862 instruction_multiplication(struct_proces
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 4936 instruction_multiplication(struct_proces	Line 4952 instruction_multiplication(struct_proces
if ((*s_objet_argument_1).type == BIN)	if ((*s_objet_argument_1).type == BIN)
{	{
(((logical8 ) (*s_objet_resultat).objet)) =	(((logical8 ) (*s_objet_resultat).objet)) =
(((integer8 ) (*s_objet_argument_2).objet))	((logical8) (((integer8 ) (*s_objet_argument_2).objet)))
* (((logical8 ) (*s_objet_argument_1).objet));	* (((logical8 ) (*s_objet_argument_1).objet));
}	}
else	else
{	{
(((logical8 ) (*s_objet_resultat).objet)) =	(((logical8 ) (*s_objet_resultat).objet)) =
(((logical8 ) (*s_objet_argument_2).objet))	(((logical8 ) (*s_objet_argument_2).objet))
* (((integer8 ) (*s_objet_argument_1).objet));	* ((logical8) (((integer8 ) (*s_objet_argument_1)
	.objet)));
}	}
}	}

Line 5862 instruction_mant(struct_processus *s_eta	Line 5879 instruction_mant(struct_processus *s_eta
return;	return;
}	}

exposant = (integer8) floor(log10((((integer8 )	exposant = (integer8) floor(log10((real8) (((integer8 )
(*s_objet_argument).objet))));	(*s_objet_argument).objet))));

base_entiere = 10;	base_entiere = 10;
Line 5870 instruction_mant(struct_processus *s_eta	Line 5887 instruction_mant(struct_processus *s_eta

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

/*	/*
Line 6129 instruction_mod(struct_processus *s_etat	Line 6146 instruction_mod(struct_processus *s_etat
struct_objet *s_objet_argument_2;	struct_objet *s_objet_argument_2;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long nombre_elements;	integer8 nombre_elements;

(*s_etat_processus).erreur_execution = d_ex;	(*s_etat_processus).erreur_execution = d_ex;

Line 6216 instruction_mod(struct_processus *s_etat	Line 6233 instruction_mod(struct_processus *s_etat
(((integer8 ) (*s_objet_resultat).objet)) =	(((integer8 ) (*s_objet_resultat).objet)) =
(((integer8 ) (*s_objet_argument_2).objet)) -	(((integer8 ) (*s_objet_argument_2).objet)) -
((((integer8 ) (s_objet_argument_1).objet))	((((integer8 ) (s_objet_argument_1).objet))
floor(((real8) (((integer8 ) (*s_objet_argument_2)	((integer8) floor(((real8) (((integer8 )
.objet))) / ((real8) (((integer8 )	(*s_objet_argument_2).objet))) / ((real8)
(*s_objet_argument_1).objet)))));	(((integer8 ) (*s_objet_argument_1).objet))))));
}	}
else	else
{	{
Line 6232 instruction_mod(struct_processus *s_etat	Line 6249 instruction_mod(struct_processus *s_etat

(((real8 ) (*s_objet_resultat).objet)) =	(((real8 ) (*s_objet_resultat).objet)) =
(((real8 ) (*s_objet_argument_2).objet)) -	(((real8 ) (*s_objet_argument_2).objet)) -
((((integer8 ) (s_objet_argument_1).objet))	((real8) (((integer8 ) (s_objet_argument_1).objet))
floor((((real8 ) (*s_objet_argument_2)	floor((((real8 ) (*s_objet_argument_2)
.objet)) / ((real8) (((integer8 )	.objet)) / ((real8) (((integer8 )
(*s_objet_argument_1).objet)))));	(*s_objet_argument_1).objet)))));
Line 6250 instruction_mod(struct_processus *s_etat	Line 6267 instruction_mod(struct_processus *s_etat
return;	return;
}	}

(((real8 ) (*s_objet_resultat).objet)) =	(((real8 ) (*s_objet_resultat).objet)) = ((real8)
(((integer8 ) (*s_objet_argument_2).objet)) -	(((integer8 ) (*s_objet_argument_2).objet))) -
((((real8 ) (s_objet_argument_1).objet))	((((real8 ) (s_objet_argument_1).objet))
floor(((real8) (((integer8 ) (*s_objet_argument_2)	floor(((real8) (((integer8 ) (*s_objet_argument_2)
.objet))) / (((real8 )	.objet))) / (((real8 )
Line 6305 instruction_mod(struct_processus *s_etat	Line 6322 instruction_mod(struct_processus *s_etat
.taille;	.taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_vecteur )
.taille * sizeof(integer8))) == NULL)	(s_objet_resultat).objet)).taille) sizeof(integer8)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6320 instruction_mod(struct_processus *s_etat	Line 6338 instruction_mod(struct_processus *s_etat
.objet)).tableau)[i] = ((integer8 *)	.objet)).tableau)[i] = ((integer8 *)
(((struct_vecteur ) (*s_objet_argument_2).objet))	(((struct_vecteur ) (*s_objet_argument_2).objet))
.tableau)[i] - ((((integer8 )	.tableau)[i] - ((((integer8 )
(s_objet_argument_1).objet)) floor(((real8)	(s_objet_argument_1).objet)) ((integer8)
((integer8 ) (((struct_vecteur *)	floor(((real8) ((integer8 ) (((struct_vecteur *)
(*s_objet_argument_2).objet)).tableau)[i]) /	(*s_objet_argument_2).objet)).tableau)[i]) /
((real8) (((integer8 ) (*s_objet_argument_1)	((real8) (((integer8 ) (*s_objet_argument_1)
.objet)))));	.objet))))));
}	}
}	}
else	else
Line 6342 instruction_mod(struct_processus *s_etat	Line 6360 instruction_mod(struct_processus *s_etat
.taille;	.taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_vecteur )
.taille * sizeof(real8))) == NULL)	(s_objet_resultat).objet)).taille) sizeof(real8)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6356 instruction_mod(struct_processus *s_etat	Line 6375 instruction_mod(struct_processus *s_etat
((real8 ) (((struct_vecteur ) (s_objet_resultat)	((real8 ) (((struct_vecteur ) (s_objet_resultat)
.objet)).tableau)[i] = ((real8 *)	.objet)).tableau)[i] = ((real8 *)
(((struct_vecteur ) (*s_objet_argument_2).objet))	(((struct_vecteur ) (*s_objet_argument_2).objet))
.tableau)[i] - ((((integer8 )	.tableau)[i] - ((real8) (((integer8 )
(s_objet_argument_1).objet)) floor(	(s_objet_argument_1).objet)) floor(
((real8 ) (((struct_vecteur *)	((real8 ) (((struct_vecteur *)
(*s_objet_argument_2).objet)).tableau)[i] /	(*s_objet_argument_2).objet)).tableau)[i] /
Line 6382 instruction_mod(struct_processus *s_etat	Line 6401 instruction_mod(struct_processus *s_etat
.taille;	.taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_vecteur )
.taille * sizeof(real8))) == NULL)	(s_objet_resultat).objet)).taille) sizeof(real8)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6394 instruction_mod(struct_processus *s_etat	Line 6414 instruction_mod(struct_processus *s_etat
.taille; i++)	.taille; i++)
{	{
((real8 ) (((struct_vecteur ) (s_objet_resultat)	((real8 ) (((struct_vecteur ) (s_objet_resultat)
.objet)).tableau)[i] = ((integer8 *)	.objet)).tableau)[i] = ((real8) ((integer8 *)
(((struct_vecteur ) (*s_objet_argument_2).objet))	(((struct_vecteur ) (*s_objet_argument_2).objet))
.tableau)[i] - ((((real8 )	.tableau)[i]) - ((((real8 )
(s_objet_argument_1).objet)) floor(((real8)	(s_objet_argument_1).objet)) floor(((real8)
((integer8 ) (((struct_vecteur *)	((integer8 ) (((struct_vecteur *)
(*s_objet_argument_2).objet)).tableau)[i]) /	(*s_objet_argument_2).objet)).tableau)[i]) /
Line 6419 instruction_mod(struct_processus *s_etat	Line 6439 instruction_mod(struct_processus *s_etat
.taille;	.taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_vecteur )
.taille * sizeof(real8))) == NULL)	(s_objet_resultat).objet)).taille) sizeof(real8)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6475 instruction_mod(struct_processus *s_etat	Line 6496 instruction_mod(struct_processus *s_etat
(*s_objet_argument_2).objet)).nombre_colonnes;	(*s_objet_argument_2).objet)).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_matrice )
.nombre_lignes * sizeof(integer8 *))) == NULL)	(s_objet_resultat).objet)).nombre_lignes)
	sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6488 instruction_mod(struct_processus *s_etat	Line 6510 instruction_mod(struct_processus *s_etat
{	{
if ((((integer8 *) (((struct_matrice *)	if ((((integer8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) (((struct_matrice )
.objet)).nombre_colonnes * sizeof(integer8)))	(*s_objet_resultat).objet)).nombre_colonnes)
== NULL)	* sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6504 instruction_mod(struct_processus *s_etat	Line 6526 instruction_mod(struct_processus *s_etat
.objet)).tableau)[i][j] = ((integer8 **)	.objet)).tableau)[i][j] = ((integer8 **)
(((struct_matrice ) (*s_objet_argument_2)	(((struct_matrice ) (*s_objet_argument_2)
.objet)).tableau)[i][j] - ((((integer8 )	.objet)).tableau)[i][j] - ((((integer8 )
(s_objet_argument_1).objet)) floor(((real8)	(s_objet_argument_1).objet))
	((integer8) floor(((real8)
((integer8 *) (((struct_matrice *)	((integer8 *) (((struct_matrice *)
(*s_objet_argument_2).objet)).tableau)[i][j]) /	(*s_objet_argument_2).objet)).tableau)[i][j]) /
((real8) (((integer8 ) (*s_objet_argument_1)	((real8) (((integer8 ) (*s_objet_argument_1)
.objet)))));	.objet))))));
}	}
}	}
}	}
Line 6530 instruction_mod(struct_processus *s_etat	Line 6553 instruction_mod(struct_processus *s_etat
(*s_objet_argument_2).objet)).nombre_colonnes;	(*s_objet_argument_2).objet)).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_matrice )
.nombre_lignes * sizeof(real8 *))) == NULL)	(s_objet_resultat).objet)).nombre_lignes)
	sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6543 instruction_mod(struct_processus *s_etat	Line 6567 instruction_mod(struct_processus *s_etat
{	{
if ((((real8 *) (((struct_matrice *)	if ((((real8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) (((struct_matrice )
.objet)).nombre_colonnes * sizeof(real8)))	(s_objet_resultat).objet)).nombre_colonnes)
== NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6558 instruction_mod(struct_processus *s_etat	Line 6582 instruction_mod(struct_processus *s_etat
((real8 *) (((struct_matrice ) (s_objet_resultat)	((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i][j] = ((real8 **)	.objet)).tableau)[i][j] = ((real8 **)
(((struct_matrice ) (*s_objet_argument_2)	(((struct_matrice ) (*s_objet_argument_2)
.objet)).tableau)[i][j] - ((((integer8 )	.objet)).tableau)[i][j] -
	((real8) (((integer8 )
(s_objet_argument_1).objet)) floor(	(s_objet_argument_1).objet)) floor(
((real8 *) (((struct_matrice *)	((real8 *) (((struct_matrice *)
(*s_objet_argument_2).objet)).tableau)[i][j] /	(*s_objet_argument_2).objet)).tableau)[i][j] /
Line 6588 instruction_mod(struct_processus *s_etat	Line 6613 instruction_mod(struct_processus *s_etat
(*s_objet_argument_2).objet)).nombre_colonnes;	(*s_objet_argument_2).objet)).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_matrice )
.nombre_lignes * sizeof(real8 *))) == NULL)	(s_objet_resultat).objet)).nombre_lignes)
	sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6601 instruction_mod(struct_processus *s_etat	Line 6627 instruction_mod(struct_processus *s_etat
{	{
if ((((real8 *) (((struct_matrice *)	if ((((real8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) (((struct_matrice )
.objet)).nombre_colonnes * sizeof(real8)))	(*s_objet_resultat).objet)).nombre_colonnes)
== NULL)	* sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6614 instruction_mod(struct_processus *s_etat	Line 6640 instruction_mod(struct_processus *s_etat
.objet)).nombre_colonnes; j++)	.objet)).nombre_colonnes; j++)
{	{
((real8 *) (((struct_matrice ) (s_objet_resultat)	((real8 *) (((struct_matrice ) (s_objet_resultat)
.objet)).tableau)[i][j] = ((integer8 **)	.objet)).tableau)[i][j] = ((real8)
	((integer8 *) (((struct_matrice *)
	(*s_objet_argument_2).objet)).tableau)[i][j])
	- ((((real8 ) (s_objet_argument_1).objet))
	floor(((real8) ((integer8 **)
(((struct_matrice ) (*s_objet_argument_2)	(((struct_matrice ) (*s_objet_argument_2)
.objet)).tableau)[i][j] - ((((real8 )	.objet)).tableau)[i][j]) / (((real8 )
(s_objet_argument_1).objet)) floor(((real8)	(*s_objet_argument_1).objet))));
((integer8 *) (((struct_matrice *)
(*s_objet_argument_2).objet)).tableau)[i][j]) /
(((real8 ) (*s_objet_argument_1)
.objet))));
}	}
}	}
}	}
Line 6643 instruction_mod(struct_processus *s_etat	Line 6669 instruction_mod(struct_processus *s_etat
(*s_objet_argument_2).objet)).nombre_colonnes;	(*s_objet_argument_2).objet)).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_matrice ) (*s_objet_resultat).objet))	malloc(((size_t) (((struct_matrice )
.nombre_lignes * sizeof(real8 *))) == NULL)	(s_objet_resultat).objet)).nombre_lignes)
	sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 6656 instruction_mod(struct_processus *s_etat	Line 6683 instruction_mod(struct_processus *s_etat
{	{
if ((((real8 *) (((struct_matrice *)	if ((((real8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) (((struct_matrice )
.objet)).nombre_colonnes * sizeof(real8)))	(s_objet_resultat).objet)).nombre_colonnes)
== NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.42
changed lines
	Added in v.1.70