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.22 and 1.73

version 1.22, 2011/06/22 13:27:01	version 1.73, 2025/04/15 10:17:54
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.0.prerelease.3	RPL/2 (R) version 4.1.36
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2025 Dr. BERTRAND Joël

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

Line 39 void	Line 39 void
instruction_moins(struct_processus *s_etat_processus)	instruction_moins(struct_processus *s_etat_processus)
{	{
integer8 tampon;	integer8 tampon;
integer8 tampon_2;

logical1 depassement;	logical1 depassement;
logical1 drapeau;	logical1 drapeau;
Line 54 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 136 instruction_moins(struct_processus *s_et	Line 135 instruction_moins(struct_processus *s_et
if (((*s_objet_argument_1).type == INT) &&	if (((*s_objet_argument_1).type == INT) &&
((*s_objet_argument_2).type == INT))	((*s_objet_argument_2).type == INT))
{	{
tampon_2 = -(((integer8 ) (*s_objet_argument_1).objet));	if (depassement_soustraction((integer8 ) (s_objet_argument_2).objet,
	(integer8 ) (s_objet_argument_1).objet, &tampon) ==
if (depassement_addition(&tampon_2,
(integer8 ) (s_objet_argument_2).objet, &tampon) ==
d_absence_erreur)	d_absence_erreur)
{	{
if ((s_objet_resultat = allocation(s_etat_processus, INT))	if ((s_objet_resultat = allocation(s_etat_processus, INT))
Line 161 instruction_moins(struct_processus *s_et	Line 158 instruction_moins(struct_processus *s_et
}	}

(((real8 ) (*s_objet_resultat).objet)) = ((real8)	(((real8 ) (*s_objet_resultat).objet)) = ((real8)
(-(((integer8 ) (*s_objet_argument_1).objet))))	(((integer8 ) (*s_objet_argument_2).objet)))
+ ((real8) (((integer8 ) (*s_objet_argument_2).objet)));	- ((real8) (((integer8 ) (*s_objet_argument_1).objet)));
}	}
}	}

Line 187 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 339 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 351 instruction_moins(struct_processus *s_et	Line 348 instruction_moins(struct_processus *s_et
for(i = 0; i < ((((struct_vecteur ) (*s_objet_resultat)	for(i = 0; i < ((((struct_vecteur ) (*s_objet_resultat)
.objet))).taille; i++)	.objet))).taille; i++)
{	{
tampon = -((integer8 ) (((struct_vecteur ) (s_objet_argument_1)	if (depassement_soustraction(&(((integer8 ) (((struct_vecteur *)
.objet)).tableau)[i];	(*s_objet_argument_2).objet)).tableau)[i]),
	&(((integer8 ) (((struct_vecteur ) (s_objet_argument_1)
if (depassement_addition(&(((integer8 ) (((struct_vecteur *)	.objet)).tableau)[i]),
(*s_objet_argument_2).objet)).tableau)[i]), &tampon,
&(((integer8 ) (((struct_vecteur *)	&(((integer8 ) (((struct_vecteur *)
(*s_objet_resultat).objet)).tableau)[i])) == d_erreur)	(*s_objet_resultat).objet)).tableau)[i])) == d_erreur)
{	{
Line 368 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 422 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 437 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 480 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 529 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 592 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 653 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 714 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 727 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 738 instruction_moins(struct_processus *s_et	Line 734 instruction_moins(struct_processus *s_et
for(j = 0; j < ((((struct_matrice ) (*s_objet_resultat).objet)))	for(j = 0; j < ((((struct_matrice ) (*s_objet_resultat).objet)))
.nombre_colonnes; j++)	.nombre_colonnes; j++)
{	{
tampon = -((integer8 *) (((struct_matrice *)	if (depassement_soustraction(&(((integer8 **)
(*s_objet_argument_1).objet)).tableau)[i][j];	(((struct_matrice ) (*s_objet_argument_2).objet))
	.tableau)[i][j]), &(((integer8 *) (((struct_matrice *)
if (depassement_addition(&(((integer8 *) (((struct_matrice *)	(*s_objet_argument_1).objet)).tableau)[i][j]),
(*s_objet_argument_2).objet)).tableau)[i][j]), &tampon,
&(((integer8 *) (((struct_matrice *)	&(((integer8 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i][j]))	(*s_objet_resultat).objet)).tableau)[i][j]))
== d_erreur)	== d_erreur)
Line 764 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 826 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 837 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 853 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 907 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 918 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 977 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 988 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 1061 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 1072 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 1143 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 1154 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 1219 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 1938 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 2088 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 2239 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 2281 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 2339 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 2352 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 2394 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 2453 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 2467 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 2508 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 2563 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 2622 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 2681 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 2740 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 2814 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 2827 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 2876 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 2947 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 2958 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 2972 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 3024 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 3035 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 3104 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 3115 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 3130 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 3181 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 3192 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 3258 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 3269 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 3338 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 3349 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 3418 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 3429 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 3498 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 3509 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 3578 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 3623 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 3683 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 3704 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 3756 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 3830 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 3851 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 3903 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 3976 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 4050 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 4124 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 4198 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 4279 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 4292 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 4335 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 4350 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 4429 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 4448 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 4464 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 4532 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 4551 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 4636 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 4655 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 4728 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 4747 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 4832 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 4851 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 4941 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 5795 instruction_mant(struct_processus *s_eta	Line 5807 instruction_mant(struct_processus *s_eta
real8 base_reelle;	real8 base_reelle;
real8 reduction_reelle;	real8 reduction_reelle;

integer4 erreur;

integer8 base_entiere;	integer8 base_entiere;
integer8 exposant;	integer8 exposant;
integer8 reduction_entiere;	integer8 reduction_entiere;
Line 5869 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 5877 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 5898 instruction_mant(struct_processus *s_eta	Line 5908 instruction_mant(struct_processus *s_eta
(*s_objet_argument).objet))));	(*s_objet_argument).objet))));

base_reelle = 10;	base_reelle = 10;
f77puissanceri_(&base_reelle, &exposant, &reduction_reelle, &erreur);	f77puissanceri_(&base_reelle, &exposant, &reduction_reelle);

if (erreur == -1)
{
if (test_cfsf(s_etat_processus, 59) == d_vrai)
{
liberation(s_etat_processus, s_objet_argument);
liberation(s_etat_processus, s_objet_resultat);

(*s_etat_processus).exception = d_ep_overflow;
return;
}
else
{
reduction_reelle = ((double) 1) / ((double) 0);
}
}

(((real8 ) (*s_objet_resultat).objet)) =	(((real8 ) (*s_objet_resultat).objet)) =
(((real8 ) (*s_objet_argument).objet)) / reduction_reelle;	(((real8 ) (*s_objet_argument).objet)) / reduction_reelle;
Line 6152 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 6239 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 6255 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 6273 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 6328 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 6343 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 6365 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 6379 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 6405 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 6417 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 6442 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 6498 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 6511 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 6527 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 6553 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 6566 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 6581 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 6611 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 6624 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 6637 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 6666 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 6679 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.22
changed lines
	Added in v.1.73