rpl/src/instructions_i2.c - diff

Return to instructions_i2.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_i2.c between versions 1.14 and 1.74

version 1.14, 2010/09/23 15:27:38	version 1.74, 2020/01/10 11:15:46
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.20	RPL/2 (R) version 4.1.32
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2020 Dr. BERTRAND Joël

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

Line 44 instruction_idn(struct_processus *s_etat	Line 44 instruction_idn(struct_processus *s_etat
logical1 argument_nom;	logical1 argument_nom;
logical1 variable_partagee;	logical1 variable_partagee;

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

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

Line 107 instruction_idn(struct_processus *s_etat	Line 107 instruction_idn(struct_processus *s_etat

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

if ((s_etat_processus).s_liste_variables[(s_etat_processus)	if (((s_etat_processus).pointeur_variable_courante)
.position_variable_courante].variable_verrouillee == d_vrai)	.variable_verrouillee == d_vrai)
{	{
(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;	(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
return;	return;
}	}

s_objet_argument = (*s_etat_processus).s_liste_variables	s_objet_argument = ((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante].objet;	.objet;

if (s_objet_argument == NULL)	if (s_objet_argument == NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
(*s_etat_processus).s_liste_variables	((s_etat_processus).pointeur_variable_courante).nom,
[(*s_etat_processus).position_variable_courante].nom,	((s_etat_processus).pointeur_variable_courante)
(*s_etat_processus).s_liste_variables	.variable_partagee, ((s_etat_processus)
[(*s_etat_processus).position_variable_courante]	.pointeur_variable_courante).origine) == NULL)
.variable_partagee, (*s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante].origine)
== d_faux)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_variable_non_definie;	d_ex_variable_non_definie;
Line 150 instruction_idn(struct_processus *s_etat	Line 133 instruction_idn(struct_processus *s_etat
}	}

s_objet_argument = ((s_etat_processus)	s_objet_argument = ((s_etat_processus)
.s_liste_variables_partagees).table[((s_etat_processus)	.pointeur_variable_partagee_courante).objet;
.s_liste_variables_partagees).position_variable].objet;
variable_partagee = d_vrai;	variable_partagee = d_vrai;
}	}
else	else
Line 184 instruction_idn(struct_processus *s_etat	Line 166 instruction_idn(struct_processus *s_etat
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 218 instruction_idn(struct_processus *s_etat	Line 200 instruction_idn(struct_processus *s_etat
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 241 instruction_idn(struct_processus *s_etat	Line 223 instruction_idn(struct_processus *s_etat
}	}

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 ) (*s_objet_resultat)
.nombre_lignes * sizeof(integer8 *))) == NULL)	.objet)).nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 262 instruction_idn(struct_processus *s_etat	Line 244 instruction_idn(struct_processus *s_etat
.nombre_lignes; i++)	.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))
sizeof(integer8))) == NULL)	.nombre_colonnes) * sizeof(integer8))) == NULL)
{	{
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 300 instruction_idn(struct_processus *s_etat	Line 282 instruction_idn(struct_processus *s_etat
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 327 instruction_idn(struct_processus *s_etat	Line 309 instruction_idn(struct_processus *s_etat
{	{
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
(s_etat_processus).s_liste_variables[(s_etat_processus)	((s_etat_processus).pointeur_variable_courante).objet = NULL;
.position_variable_courante].objet = NULL;	((s_etat_processus).pointeur_variable_partagee_courante).objet =
((s_etat_processus).s_liste_variables_partagees).table	s_objet_resultat;
[((s_etat_processus).s_liste_variables_partagees)
.position_variable].objet = s_objet_resultat;

if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 342 instruction_idn(struct_processus *s_etat	Line 322 instruction_idn(struct_processus *s_etat
}	}
else	else
{	{
(s_etat_processus).s_liste_variables[(s_etat_processus)	((s_etat_processus).pointeur_variable_courante).objet =
.position_variable_courante].objet = s_objet_resultat;	s_objet_resultat;
}	}
}	}

Line 379 instruction_ifft(struct_processus *s_eta	Line 359 instruction_ifft(struct_processus *s_eta

logical1 presence_longueur_fft;	logical1 presence_longueur_fft;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long k;	integer8 k;
unsigned long longueur_fft;	integer8 longueur_fft;

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

Line 488 instruction_ifft(struct_processus *s_eta	Line 468 instruction_ifft(struct_processus *s_eta
{	{
if (presence_longueur_fft == d_faux)	if (presence_longueur_fft == d_faux)
{	{
longueur_fft = pow(2, (integer4) ceil(log((real8)	longueur_fft = (integer8) pow(2, ceil(log((real8)
(((struct_vecteur )	(((struct_vecteur )
(*s_objet_argument).objet)).taille) / log((real8) 2)));	(*s_objet_argument).objet)).taille) / log((real8) 2)));

if ((longueur_fft / ((real8) (((struct_vecteur )	if ((((real8) longueur_fft) / ((real8) (((struct_vecteur )
(*s_objet_argument).objet)).taille)) == 2)	(*s_objet_argument).objet)).taille)) == 2)
{	{
longueur_fft /= 2;	longueur_fft /= 2;
}	}
}	}

if ((matrice_f77 = malloc(longueur_fft *	if ((matrice_f77 = malloc(((size_t) longueur_fft) *
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 549 instruction_ifft(struct_processus *s_eta	Line 529 instruction_ifft(struct_processus *s_eta
}	}

nombre_lignes = 1;	nombre_lignes = 1;
nombre_colonnes = longueur_fft;	nombre_colonnes = (integer4) longueur_fft;
inverse = -1;	inverse = -1;

dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);	dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
Line 585 instruction_ifft(struct_processus *s_eta	Line 565 instruction_ifft(struct_processus *s_eta
{	{
if (presence_longueur_fft == d_faux)	if (presence_longueur_fft == d_faux)
{	{
longueur_fft = pow(2, (integer4) ceil(log((real8)	longueur_fft = (integer8) pow(2, ceil(log((real8)
(((struct_matrice )	(((struct_matrice ) (*s_objet_argument).objet))
(*s_objet_argument).objet)).nombre_colonnes) /	.nombre_colonnes) / log((real8) 2)));
log((real8) 2)));

if ((longueur_fft / ((real8) (((struct_matrice )	if ((((real8) longueur_fft) / ((real8) (((struct_matrice )
(*s_objet_argument).objet)).nombre_colonnes)) == 2)	(*s_objet_argument).objet)).nombre_colonnes)) == 2)
{	{
longueur_fft /= 2;	longueur_fft /= 2;
}	}
}	}

if ((matrice_f77 = malloc(longueur_fft *	if ((matrice_f77 = malloc(((size_t) longueur_fft) *
(((struct_matrice ) (*s_objet_argument).objet))	((size_t) (((struct_matrice ) (*s_objet_argument).objet))
.nombre_lignes * sizeof(struct_complexe16))) == NULL)	.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 675 instruction_ifft(struct_processus *s_eta	Line 654 instruction_ifft(struct_processus *s_eta
}	}
}	}

nombre_lignes = (((struct_matrice ) (*s_objet_argument).objet))	nombre_lignes = (integer4) (((struct_matrice )
.nombre_lignes;	(*s_objet_argument).objet)).nombre_lignes;
nombre_colonnes = longueur_fft;	nombre_colonnes = (integer4) longueur_fft;
inverse = -1;	inverse = -1;

dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);	dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
Line 704 instruction_ifft(struct_processus *s_eta	Line 683 instruction_ifft(struct_processus *s_eta
longueur_fft;	longueur_fft;

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 ) (*s_objet_resultat)
.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 716 instruction_ifft(struct_processus *s_eta	Line 695 instruction_ifft(struct_processus *s_eta
{	{
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 786 instruction_input(struct_processus *s_et	Line 765 instruction_input(struct_processus *s_et
{	{
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

	unsigned char *ptr_e;
	unsigned char *ptr_l;
unsigned char *tampon;	unsigned char *tampon;
	unsigned char *tampon2;

	integer8 i;

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

Line 828 instruction_input(struct_processus *s_et	Line 812 instruction_input(struct_processus *s_et
}	}

flockfile(stdin);	flockfile(stdin);

(s_objet_resultat).objet = (void ) readline("");	(s_objet_resultat).objet = (void ) readline("");
funlockfile(stdin);	funlockfile(stdin);

Line 852 instruction_input(struct_processus *s_et	Line 837 instruction_input(struct_processus *s_et
}	}

free((unsigned char ) (s_objet_resultat).objet);	free((unsigned char ) (s_objet_resultat).objet);
(*s_objet_resultat).objet = tampon;
	ptr_l = tampon;
	i = 0;

	while((*ptr_l) != d_code_fin_chaine)
	{
	if ((*ptr_l) == '\"')
	{
	i++;
	}

	ptr_l++;
	}

	if ((tampon2 = malloc((strlen(tampon) + 1 + ((size_t) i)) *
	sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return;
	}

	ptr_l = tampon;
	ptr_e = tampon2;

	while((*ptr_l) != d_code_fin_chaine)
	{
	if ((*ptr_l) == '\"')
	{
	(*ptr_e) = '\\';
	ptr_e++;
	}

	(ptr_e) = (ptr_l);
	ptr_e++;
	ptr_l++;
	}

	free(tampon);
	(*s_objet_resultat).objet = tampon2;

add_history((unsigned char ) (s_objet_resultat).objet);	add_history((unsigned char ) (s_objet_resultat).objet);
stifle_history(ds_longueur_historique);	stifle_history(ds_longueur_historique);
Line 1037 instruction_int(struct_processus *s_etat	Line 1060 instruction_int(struct_processus *s_etat

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("(intégration numérique)\n\n");	printf("(intégration)\n\n");
}	}
else	else
{	{
printf("(numerical integration)\n\n");	printf("(numerical)\n\n");
}	}

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

	printf(" 2: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
	printf(" 1: %s\n", d_NOM);
	printf("-> 1: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
return;	return;
}	}
else if ((*s_etat_processus).test_instruction == 'Y')	else if ((*s_etat_processus).test_instruction == 'Y')
{	{
(*s_etat_processus).nombre_arguments = 3;	(*s_etat_processus).nombre_arguments = -1;
return;	return;
}	}

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

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

if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if ((((*s_etat_processus).l_base_pile).donnee).type == NOM)
&s_objet_argument_2) == d_erreur)
{	{
liberation(s_etat_processus, s_objet_argument_1);	// Intégration symbolique

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

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

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

if ((*s_objet_argument_1).type == INT)	(*s_etat_processus).erreur_execution = d_ex_manque_argument;
{	return;
precision = (((integer8 ) (*s_objet_argument_1).objet));	}
}
else if ((*s_objet_argument_1).type == REL)	if (((*s_objet_argument_1).type == NOM) &&
{	(((*s_objet_argument_2).type == NOM) \|\|
precision = (((real8 ) (*s_objet_argument_1).objet));	((*s_objet_argument_2).type == ALG) \|\|
	((*s_objet_argument_2).type == REL) \|\|
	((*s_objet_argument_2).type == INT)))
	{
	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
	s_objet_argument_2) == d_erreur)
	{
	return;
	}

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

	interface_cas(s_etat_processus, RPLCAS_INTEGRATION);
	}
	else
	{
	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

	(*s_etat_processus).erreur_execution =
	d_ex_erreur_type_argument;
	return;
	}
}	}
else	else
{	{
liberation(s_etat_processus, s_objet_argument_1);	// Intégration numérique
liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);

(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;	if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
return;	{
}	if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
	{
	return;
	}
	}

if ((*s_objet_argument_2).type == LST)	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
{	&s_objet_argument_1) == d_erreur)
l_element_courant = (*s_objet_argument_2).objet;	{
	(*s_etat_processus).erreur_execution = d_ex_manque_argument;
	return;
	}

if (((l_element_courant).donnee).type != NOM)	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
	&s_objet_argument_2) == d_erreur)
{	{
liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);

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

if ((nom_variable = malloc((strlen((((struct_nom )	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
((l_element_courant).donnee).objet)).nom)	&s_objet_argument_3) == d_erreur)
+ 1) * sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

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

strcpy(nom_variable, (((struct_nom ) ((l_element_courant)	if (((*s_objet_argument_3).type != NOM) &&
.donnee).objet)).nom);	((*s_objet_argument_3).type != ALG) &&
	((*s_objet_argument_3).type != RPN) &&
	((*s_objet_argument_3).type != REL) &&
	((*s_objet_argument_3).type != INT))
	{
	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);
	liberation(s_etat_processus, s_objet_argument_3);

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

if (((l_element_courant).donnee).type == INT)	if ((*s_objet_argument_1).type == INT)
{	{
borne_minimale = (real8) (((integer8 )	precision = (real8) (((integer8 ) (*s_objet_argument_1).objet));
((l_element_courant).donnee).objet));
}	}
else if (((l_element_courant).donnee).type == REL)	else if ((*s_objet_argument_1).type == REL)
{	{
borne_minimale = (((real8 ) ((l_element_courant)	precision = (((real8 ) (*s_objet_argument_1).objet));
.donnee).objet));
}	}
else	else
{	{
if (evaluation(s_etat_processus, (*l_element_courant).donnee,	liberation(s_etat_processus, s_objet_argument_1);
'N') == d_erreur)	liberation(s_etat_processus, s_objet_argument_2);
	liberation(s_etat_processus, s_objet_argument_3);

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

	if ((*s_objet_argument_2).type == LST)
	{
	l_element_courant = (*s_objet_argument_2).objet;

	if (((l_element_courant).donnee).type != NOM)
{	{
free(nom_variable);
liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);	liberation(s_etat_processus, s_objet_argument_3);

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

if (depilement(s_etat_processus, &((*s_etat_processus)	if ((nom_variable = malloc((strlen((((struct_nom )
.l_base_pile), &s_objet_evalue) == d_erreur)	((l_element_courant).donnee).objet)).nom)
	+ 1) * sizeof(unsigned char))) == NULL)
{	{
free(nom_variable);	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);

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

if ((*s_objet_evalue).type == INT)	strcpy(nom_variable, (((struct_nom ) ((l_element_courant)
	.donnee).objet)).nom);

	l_element_courant = (*l_element_courant).suivant;

	if (((l_element_courant).donnee).type == INT)
{	{
borne_minimale = (real8) (((integer8 )	borne_minimale = (real8) (((integer8 )
(*s_objet_evalue).objet));	((l_element_courant).donnee).objet));
}	}
else if ((*s_objet_evalue).type == REL)	else if (((l_element_courant).donnee).type == REL)
{	{
borne_minimale = (((real8 ) (*s_objet_evalue).objet));	borne_minimale = (((real8 ) ((l_element_courant)
	.donnee).objet));
}	}
else	else
{	{
free(nom_variable);	if (evaluation(s_etat_processus, (*l_element_courant).donnee,
	'N') == d_erreur)
liberation(s_etat_processus, s_objet_evalue);	{
liberation(s_etat_processus, s_objet_argument_1);	free(nom_variable);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_3);	liberation(s_etat_processus, s_objet_argument_2);
	liberation(s_etat_processus, s_objet_argument_3);
(*s_etat_processus).erreur_execution =
d_ex_erreur_type_argument;
return;
}

liberation(s_etat_processus, s_objet_evalue);	return;
}	}

l_element_courant = (*l_element_courant).suivant;	if (depilement(s_etat_processus, &((*s_etat_processus)
	.l_base_pile), &s_objet_evalue) == d_erreur)
	{
	free(nom_variable);
	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);
	liberation(s_etat_processus, s_objet_argument_3);

if (((l_element_courant).donnee).type == INT)	(*s_etat_processus).erreur_execution =
{	d_ex_manque_argument;
borne_maximale = (real8) (((integer8 )	return;
((l_element_courant).donnee).objet));	}
}
else if (((l_element_courant).donnee).type == REL)
{
borne_maximale = (((real8 ) ((l_element_courant)
.donnee).objet));
}
else
{
if (evaluation(s_etat_processus, (*l_element_courant).donnee,
'N') == d_erreur)
{
free(nom_variable);
liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);

return;	if ((*s_objet_evalue).type == INT)
}	{
	borne_minimale = (real8) (((integer8 )
	(*s_objet_evalue).objet));
	}
	else if ((*s_objet_evalue).type == REL)
	{
	borne_minimale = (((real8 ) (*s_objet_evalue).objet));
	}
	else
	{
	free(nom_variable);

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

if (depilement(s_etat_processus, &((*s_etat_processus)	(*s_etat_processus).erreur_execution =
.l_base_pile), &s_objet_evalue) == d_erreur)	d_ex_erreur_type_argument;
{	return;
free(nom_variable);	}
liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);

(*s_etat_processus).erreur_execution =	liberation(s_etat_processus, s_objet_evalue);
d_ex_manque_argument;
return;
}	}

if ((*s_objet_evalue).type == INT)	l_element_courant = (*l_element_courant).suivant;

	if (((l_element_courant).donnee).type == INT)
{	{
borne_maximale = (real8) (((integer8 )	borne_maximale = (real8) (((integer8 )
(*s_objet_evalue).objet));	((l_element_courant).donnee).objet));
}	}
else if ((*s_objet_evalue).type == REL)	else if (((l_element_courant).donnee).type == REL)
{	{
borne_maximale = (((real8 ) (*s_objet_evalue).objet));	borne_maximale = (((real8 ) ((l_element_courant)
	.donnee).objet));
}	}
else	else
{	{
free(nom_variable);	if (evaluation(s_etat_processus, (*l_element_courant).donnee,
	'N') == d_erreur)
	{
	free(nom_variable);
	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);
	liberation(s_etat_processus, s_objet_argument_3);

liberation(s_etat_processus, s_objet_evalue);	return;
liberation(s_etat_processus, s_objet_argument_1);	}
liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);

(*s_etat_processus).erreur_execution =	if (depilement(s_etat_processus, &((*s_etat_processus)
d_ex_erreur_type_argument;	.l_base_pile), &s_objet_evalue) == d_erreur)
return;	{
	free(nom_variable);
	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);
	liberation(s_etat_processus, s_objet_argument_3);

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

	if ((*s_objet_evalue).type == INT)
	{
	borne_maximale = (real8) (((integer8 )
	(*s_objet_evalue).objet));
	}
	else if ((*s_objet_evalue).type == REL)
	{
	borne_maximale = (((real8 ) (*s_objet_evalue).objet));
	}
	else
	{
	free(nom_variable);

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

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

	liberation(s_etat_processus, s_objet_evalue);
}	}

liberation(s_etat_processus, s_objet_evalue);	/*
}	* Le résultat est retourné sur la pile par la routine
	*/

/*	if (last_valide == d_vrai)
* Le résultat est retourné sur la pile par la routine	{
*/	cf(s_etat_processus, 31);
	}

if (last_valide == d_vrai)	integrale_romberg(s_etat_processus, s_objet_argument_3,
{	nom_variable, borne_minimale, borne_maximale, precision);
cf(s_etat_processus, 31);
}

integrale_romberg(s_etat_processus, s_objet_argument_3, nom_variable,	if (last_valide == d_vrai)
borne_minimale, borne_maximale, precision);	{
	sf(s_etat_processus, 31);
	}

if (last_valide == d_vrai)	free(nom_variable);
	}
	else
{	{
sf(s_etat_processus, 31);	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);
	liberation(s_etat_processus, s_objet_argument_3);

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

free(nom_variable);
}
else
{
liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_argument_2);	liberation(s_etat_processus, s_objet_argument_2);
liberation(s_etat_processus, s_objet_argument_3);	liberation(s_etat_processus, s_objet_argument_3);

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

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

return;	return;
}	}

Line 1397 instruction_incr(struct_processus *s_eta	Line 1508 instruction_incr(struct_processus *s_eta

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

if ((*s_etat_processus).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante]
.variable_verrouillee == d_vrai)	.variable_verrouillee == d_vrai)
{	{
(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;	(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
return;	return;
}	}

if ((*s_etat_processus).s_liste_variables	if (((s_etat_processus).pointeur_variable_courante).objet == NULL)
[(*s_etat_processus).position_variable_courante].objet
== NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if (recherche_variable_partagee(s_etat_processus,	if (recherche_variable_partagee(s_etat_processus,
(*s_etat_processus).s_liste_variables	((s_etat_processus).pointeur_variable_courante).nom,
[(*s_etat_processus).position_variable_courante].nom,	((s_etat_processus).pointeur_variable_courante)
(*s_etat_processus).s_liste_variables	.variable_partagee, ((s_etat_processus)
[(*s_etat_processus).position_variable_courante]	.pointeur_variable_courante).origine) == NULL)
.variable_partagee, (*s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante]
.origine) == d_faux)
{	{
(*s_etat_processus).erreur_systeme = d_es;	(*s_etat_processus).erreur_systeme = d_es;
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
Line 1433 instruction_incr(struct_processus *s_eta	Line 1531 instruction_incr(struct_processus *s_eta
}	}

s_objet_argument = ((s_etat_processus)	s_objet_argument = ((s_etat_processus)
.s_liste_variables_partagees).table	.pointeur_variable_partagee_courante).objet;
[((s_etat_processus).s_liste_variables_partagees)
.position_variable].objet;
variable_partagee = d_vrai;	variable_partagee = d_vrai;
}	}
else	else
{	{
s_objet_argument = (*s_etat_processus).s_liste_variables	s_objet_argument = ((s_etat_processus).pointeur_variable_courante)
[(*s_etat_processus).position_variable_courante].objet;	.objet;
variable_partagee = d_faux;	variable_partagee = d_faux;
}	}

Line 1451 instruction_incr(struct_processus *s_eta	Line 1547 instruction_incr(struct_processus *s_eta
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1466 instruction_incr(struct_processus *s_eta	Line 1562 instruction_incr(struct_processus *s_eta

if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
(s_etat_processus).s_liste_variables[(s_etat_processus)	((s_etat_processus).pointeur_variable_courante).objet = NULL;
.position_variable_courante].objet = NULL;	((s_etat_processus).pointeur_variable_partagee_courante).objet =
((s_etat_processus)	s_copie_argument;
.s_liste_variables_partagees).table
[((s_etat_processus).s_liste_variables_partagees)
.position_variable].objet = s_copie_argument;
}	}
else	else
{	{
(s_etat_processus).s_liste_variables[(s_etat_processus)	((s_etat_processus).pointeur_variable_courante).objet =
.position_variable_courante].objet = s_copie_argument;	s_copie_argument;
}	}

if ((*s_copie_argument).type == INT)	if ((*s_copie_argument).type == INT)
Line 1486 instruction_incr(struct_processus *s_eta	Line 1579 instruction_incr(struct_processus *s_eta
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1498 instruction_incr(struct_processus *s_eta	Line 1591 instruction_incr(struct_processus *s_eta
if (variable_partagee == d_vrai)	if (variable_partagee == d_vrai)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.pointeur_variable_partagee_courante).mutex)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.14
changed lines
	Added in v.1.74