rpl/src/instructions_d1.c - diff - 1.53

Return to instructions_d1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_d1.c between versions 1.31 and 1.53

version 1.31, 2011/11/26 10:01:28	version 1.53, 2015/01/05 15:32:17
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.5	RPL/2 (R) version 4.1.20
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2015 Dr. BERTRAND Joël

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

Line 525 instruction_dropn(struct_processus *s_et	Line 525 instruction_dropn(struct_processus *s_et
{	{
struct_objet *s_objet;	struct_objet *s_objet;

signed long nombre_suppressions;	integer8 nombre_suppressions;

unsigned long i;	integer8 i;

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

Line 624 instruction_dropn(struct_processus *s_et	Line 624 instruction_dropn(struct_processus *s_et
return;	return;
}	}

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

for(i = 0; i < (unsigned long) nombre_suppressions; i++)	for(i = 0; i < nombre_suppressions; i++)
{	{
if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
&s_objet) == d_erreur)	&s_objet) == d_erreur)
Line 762 instruction_dup2(struct_processus *s_eta	Line 761 instruction_dup2(struct_processus *s_eta
{	{
struct_objet *s_objet;	struct_objet *s_objet;

unsigned long i;	integer8 i;

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

Line 879 instruction_dupn(struct_processus *s_eta	Line 878 instruction_dupn(struct_processus *s_eta
struct_objet *s_objet;	struct_objet *s_objet;
struct_objet *s_nouvel_objet;	struct_objet *s_nouvel_objet;

signed long nombre_duplications;	integer8 nombre_duplications;
unsigned long i;	integer8 i;

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

Line 979 instruction_dupn(struct_processus *s_eta	Line 978 instruction_dupn(struct_processus *s_eta

l_element_courant = (*s_etat_processus).l_base_pile;	l_element_courant = (*s_etat_processus).l_base_pile;

for(i = 0; i < (unsigned long) nombre_duplications; i++)	for(i = 0; i < nombre_duplications; i++)
{	{
if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
Line 1005 instruction_dupn(struct_processus *s_eta	Line 1004 instruction_dupn(struct_processus *s_eta
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
}	}

for(i = 0; i < (unsigned long) nombre_duplications; i++)	for(i = 0; i < nombre_duplications; i++)
{	{
if (depilement(s_etat_processus, &l_base_pile, &s_objet) == d_erreur)	if (depilement(s_etat_processus, &l_base_pile, &s_objet) == d_erreur)
{	{
Line 1057 instruction_division(struct_processus *s	Line 1056 instruction_division(struct_processus *s
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;

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

Line 2054 instruction_division(struct_processus *s	Line 2053 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).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 2084 instruction_division(struct_processus *s	Line 2083 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).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 2151 instruction_division(struct_processus *s	Line 2150 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).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 2212 instruction_division(struct_processus *s	Line 2211 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).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 2280 instruction_division(struct_processus *s	Line 2279 instruction_division(struct_processus *s
(((struct_vecteur ) (*s_objet_argument_2).objet)).taille;	(((struct_vecteur ) (*s_objet_argument_2).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 2373 instruction_division(struct_processus *s	Line 2372 instruction_division(struct_processus *s
.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 2384 instruction_division(struct_processus *s	Line 2383 instruction_division(struct_processus *s
.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(((((struct_matrice )	.objet)).tableau)[i] = malloc(((size_t)
(s_objet_resultat).objet))).nombre_colonnes	((((struct_matrice )
	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(integer8))) == NULL)	sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2421 instruction_division(struct_processus *s	Line 2421 instruction_division(struct_processus *s
.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 2453 instruction_division(struct_processus *s	Line 2453 instruction_division(struct_processus *s
.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(((((struct_matrice )	.objet)).tableau)[i] = malloc(((size_t)
(s_objet_resultat).objet))).nombre_colonnes	((((struct_matrice )
	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2506 instruction_division(struct_processus *s	Line 2507 instruction_division(struct_processus *s
.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 2530 instruction_division(struct_processus *s	Line 2532 instruction_division(struct_processus *s
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc(((((struct_matrice )	malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2585 instruction_division(struct_processus *s	Line 2587 instruction_division(struct_processus *s
.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 2617 instruction_division(struct_processus *s	Line 2620 instruction_division(struct_processus *s
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc(((((struct_matrice )	malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2671 instruction_division(struct_processus *s	Line 2674 instruction_division(struct_processus *s
.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 2695 instruction_division(struct_processus *s	Line 2699 instruction_division(struct_processus *s
{	{
if ((((struct_complexe16 *) (((struct_matrice *)	if ((((struct_complexe16 *) (((struct_matrice *)
(*s_objet_resultat).objet)).tableau)[i] =	(*s_objet_resultat).objet)).tableau)[i] =
malloc(((((struct_matrice )	malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 2757 instruction_division(struct_processus *s	Line 2761 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(real8))) == NULL)	(s_objet_resultat).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 2808 instruction_division(struct_processus *s	Line 2812 instruction_division(struct_processus *s
(*s_objet_resultat).objet))	(*s_objet_resultat).objet))
.tableau)[i] += ((real8 *) (((struct_matrice *)	.tableau)[i] += ((real8 *) (((struct_matrice *)
(s_objet_argument_1).objet)).tableau)[i][j]	(s_objet_argument_1).objet)).tableau)[i][j]
((integer8 ) (((struct_vecteur *)	(real8) ((integer8 ) (((struct_vecteur *)
(*s_objet_argument_2).objet)).tableau)[j];	(*s_objet_argument_2).objet)).tableau)[j];
}	}
else	else
Line 2855 instruction_division(struct_processus *s	Line 2859 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(struct_complexe16)))	(s_objet_resultat).objet)).taille)
== NULL)	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 2968 instruction_division(struct_processus *s	Line 2972 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(struct_complexe16)))	(s_objet_resultat).objet)).taille)
== NULL)	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 3068 instruction_division(struct_processus *s	Line 3072 instruction_division(struct_processus *s
.objet))).taille;	.objet))).taille;

if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =	if (((((struct_vecteur ) (*s_objet_resultat).objet)).tableau =
malloc((((struct_vecteur )	malloc(((size_t) (((struct_vecteur )
(s_objet_resultat).objet)).taille sizeof(struct_complexe16)))	(s_objet_resultat).objet)).taille)
== NULL)	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 3172 instruction_division(struct_processus *s	Line 3176 instruction_division(struct_processus *s
.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 )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_lignes sizeof(real8 *)))	(s_objet_resultat).objet)).nombre_lignes) sizeof(real8 *)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3214 instruction_division(struct_processus *s	Line 3218 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).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 )	= 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 = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3238 instruction_division(struct_processus *s	Line 3242 instruction_division(struct_processus *s
.tableau)[i][j] += ((real8 **)	.tableau)[i][j] += ((real8 **)
(((struct_matrice )	(((struct_matrice )
(s_objet_argument_1).objet)).tableau)[i][k]	(s_objet_argument_1).objet)).tableau)[i][k]
((integer8 *) (((struct_matrice *)	(real8) ((integer8 *) (((struct_matrice *)
(*s_objet_argument_2).objet)).tableau)[k][j];	(*s_objet_argument_2).objet)).tableau)[k][j];
}	}
else	else
Line 3289 instruction_division(struct_processus *s	Line 3293 instruction_division(struct_processus *s
.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 )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_lignes	(s_objet_resultat).objet)).nombre_lignes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3330 instruction_division(struct_processus *s	Line 3334 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).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 )	= malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3416 instruction_division(struct_processus *s	Line 3420 instruction_division(struct_processus *s
.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 )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_lignes	(s_objet_resultat).objet)).nombre_lignes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3457 instruction_division(struct_processus *s	Line 3461 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).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 )	= malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3533 instruction_division(struct_processus *s	Line 3537 instruction_division(struct_processus *s
.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 )	malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3574 instruction_division(struct_processus *s	Line 3578 instruction_division(struct_processus *s
(*s_objet_resultat).objet)).nombre_lignes; i++)	(*s_objet_resultat).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 )	= malloc(((size_t) (((struct_matrice )
(s_objet_resultat).objet)).nombre_colonnes	(s_objet_resultat).objet)).nombre_colonnes)
sizeof(struct_complexe16))) == NULL)	sizeof(struct_complexe16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 3670 instruction_division(struct_processus *s	Line 3674 instruction_division(struct_processus *s

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

Line 3817 instruction_default(struct_processus *s_	Line 3822 instruction_default(struct_processus *s_
unsigned char *instruction_majuscule;	unsigned char *instruction_majuscule;
unsigned char *tampon;	unsigned char *tampon;

unsigned long niveau;	integer8 niveau;

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

Line 3942 instruction_default(struct_processus *s_	Line 3947 instruction_default(struct_processus *s_
{	{
if ((*s_etat_processus).mode_execution_programme == 'Y')	if ((*s_etat_processus).mode_execution_programme == 'Y')
{	{
(*s_etat_processus).position_courante -= (strlen(	(*s_etat_processus).position_courante -=
	(integer8) (strlen(
instruction_majuscule) + 1);	instruction_majuscule) + 1);
}	}
else	else

CVSweb interface <joel.bertrand@systella.fr>