rpl/src/instructions_s9.c - diff

Return to instructions_s9.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_s9.c between versions 1.3 and 1.28

version 1.3, 2010/02/10 10:14:25	version 1.28, 2011/06/20 17:54:20
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.11	RPL/2 (R) version 4.1.0.prerelease.1
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

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

Line 20	Line 20
*/	*/


#include "rpl.conv.h"	#include "rpl-conv.h"


/*	/*
Line 57 instruction_sort(struct_processus *s_eta	Line 57 instruction_sort(struct_processus *s_eta
struct_objet *s_objet_copie;	struct_objet *s_objet_copie;
struct_objet *s_objet_critere;	struct_objet *s_objet_critere;
struct_objet *s_objet_liste;	struct_objet *s_objet_liste;
	struct_objet *s_objet_registre;
struct_objet *s_objet_test;	struct_objet *s_objet_test;

signed long indice_i;	signed long indice_i;
Line 140 instruction_sort(struct_processus *s_eta	Line 141 instruction_sort(struct_processus *s_eta
return;	return;
}	}

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;

Line 151 instruction_sort(struct_processus *s_eta	Line 152 instruction_sort(struct_processus *s_eta
return;	return;
}	}

if ((s_etat_processus).s_liste_variables[(s_etat_processus)	if (((s_etat_processus).pointeur_variable_courante).objet == NULL)
.position_variable_courante].objet == NULL)
{	{
if (pthread_mutex_lock(&(((s_etat_processus)	if (pthread_mutex_lock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.s_liste_variables_partagees).mutex)) != 0)
Line 162 instruction_sort(struct_processus *s_eta	Line 162 instruction_sort(struct_processus *s_eta
}	}

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) == d_faux)
.variable_partagee, (*s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante].origine)
== d_faux)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.s_liste_variables_partagees).mutex)) != 0)
Line 186 instruction_sort(struct_processus *s_eta	Line 183 instruction_sort(struct_processus *s_eta
return;	return;
}	}

if ((((*s_etat_processus).s_liste_variables_partagees)	if (((((*s_etat_processus).s_liste_variables_partagees)
.table[((s_etat_processus).s_liste_variables_partagees)	.table[((s_etat_processus).s_liste_variables_partagees)
.position_variable].objet).type != LST)	.position_variable].objet).type != LST) &&
	((((*s_etat_processus).s_liste_variables_partagees)
	.table[((s_etat_processus).s_liste_variables_partagees)
	.position_variable].objet).type != TBL))
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (pthread_mutex_unlock(&(((s_etat_processus)
.s_liste_variables_partagees).mutex)) != 0)	.s_liste_variables_partagees).mutex)) != 0)
Line 230 instruction_sort(struct_processus *s_eta	Line 230 instruction_sort(struct_processus *s_eta
}	}
else	else
{	{
if (((s_etat_processus).s_liste_variables	if (((((*s_etat_processus).pointeur_variable_courante).objet)
[(*s_etat_processus).position_variable_courante].objet)	.type != LST) && ((((*s_etat_processus)
.type != LST)	.pointeur_variable_courante).objet).type != TBL))
{	{
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_erreur_type_argument;	d_ex_erreur_type_argument;
Line 245 instruction_sort(struct_processus *s_eta	Line 245 instruction_sort(struct_processus *s_eta

liberation(s_etat_processus, s_objet_liste);	liberation(s_etat_processus, s_objet_liste);

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

if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,	if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
'N')) == NULL)	'N')) == NULL)
Line 258 instruction_sort(struct_processus *s_eta	Line 258 instruction_sort(struct_processus *s_eta

liberation(s_etat_processus, s_objet_liste);	liberation(s_etat_processus, s_objet_liste);
s_objet_liste = s_objet_copie;	s_objet_liste = s_objet_copie;
	((s_etat_processus).pointeur_variable_courante).objet = s_objet_liste;
(s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].objet = s_objet_liste;

presence_nom = d_vrai;	presence_nom = d_vrai;
}	}
else	else
Line 457 instruction_sort(struct_processus *s_eta	Line 454 instruction_sort(struct_processus *s_eta
indice_j = 0;	indice_j = 0;
indice_k = (((struct_tableau ) (*s_objet_liste).objet))	indice_k = (((struct_tableau ) (*s_objet_liste).objet))
.nombre_elements - ecartement;	.nombre_elements - ecartement;

terminaison_boucle_2 = d_faux;	terminaison_boucle_2 = d_faux;

do	do
Line 551 instruction_sort(struct_processus *s_eta	Line 547 instruction_sort(struct_processus *s_eta

if (condition == d_faux)	if (condition == d_faux)
{	{
swap((void ) (((struct_tableau *)	s_objet_registre =
(*s_objet_liste).objet)).elements	(((struct_tableau )
[indice_i - 1], (void *)	(*s_objet_liste).objet)).elements
(((struct_tableau ) (*s_objet_liste)	[indice_i - 1];
.objet)).elements[indice_l - 1],	(((struct_tableau ) (*s_objet_liste).objet))
sizeof(struct_objet));	.elements[indice_i - 1] =
	(((struct_tableau ) (*s_objet_liste)
	.objet)).elements[indice_l - 1];
	(((struct_tableau ) (*s_objet_liste)
	.objet)).elements[indice_l - 1] =
	s_objet_registre;

indice_i -= ecartement;	indice_i -= ecartement;

Line 652 instruction_sort(struct_processus *s_eta	Line 653 instruction_sort(struct_processus *s_eta
void	void
instruction_save(struct_processus *s_etat_processus)	instruction_save(struct_processus *s_etat_processus)
{	{
logical1 presence_variable;

long i;

struct_objet *s_objet_1;	struct_objet *s_objet_1;
struct_objet *s_objet_2;	struct_objet *s_objet_2;

Line 727 instruction_save(struct_processus *s_eta	Line 724 instruction_save(struct_processus *s_eta
return;	return;
}	}

if (recherche_variable(s_etat_processus, (((struct_nom )	if (recherche_variable_globale(s_etat_processus, (((struct_nom )
(*s_objet_1).objet)).nom) == d_vrai)	(*s_objet_1).objet)).nom) == d_vrai)
{	{
/*	/*
* Une variable est accessible directement.	* Une variable est accessible.
*/	*/

if ((s_etat_processus).s_liste_variables[(s_etat_processus)	if (((s_etat_processus).pointeur_variable_courante)
.position_variable_courante].niveau == 1)	.variable_verrouillee == d_vrai)
{	{
// La variable accessible directement est une variable globale.	liberation(s_etat_processus, s_objet_1);
	liberation(s_etat_processus, s_objet_2);
if ((s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].variable_verrouillee == d_vrai)
{
liberation(s_etat_processus, s_objet_1);
liberation(s_etat_processus, s_objet_2);

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

if ((s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].objet == NULL)
{
liberation(s_etat_processus, s_objet_1);
liberation(s_etat_processus, s_objet_2);

(*s_etat_processus).erreur_execution = d_ex_variable_partagee;	(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
return;	return;
}

liberation(s_etat_processus,
(s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].objet);

(s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].objet = s_objet_2;
}	}
else
{
// On cherche une variable globale de même nom.

i = (*s_etat_processus).position_variable_courante;
presence_variable = d_faux;

while(i >= 0)
{
if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,
(((struct_nom ) (*s_objet_1).objet)).nom) == 0) &&
((*s_etat_processus).s_liste_variables[i].niveau == 1))
{
presence_variable = d_vrai;
break;
}

i--;
}

(*s_etat_processus).position_variable_courante = i;	if (((s_etat_processus).pointeur_variable_courante).objet == NULL)
	{
if ((s_etat_processus).s_liste_variables[(s_etat_processus)	liberation(s_etat_processus, s_objet_1);
.position_variable_courante].niveau == 1)	liberation(s_etat_processus, s_objet_2);
{
// On a trouvé une variable globale correspondant au nom et
// que l'on modifie.

if ((s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].variable_verrouillee ==
d_vrai)
{
liberation(s_etat_processus, s_objet_1);
liberation(s_etat_processus, s_objet_2);

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

if ((s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].objet == NULL)
{
liberation(s_etat_processus, s_objet_1);
liberation(s_etat_processus, s_objet_2);

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

liberation(s_etat_processus,
(*s_etat_processus).s_liste_variables
[(*s_etat_processus).position_variable_courante].objet);

(s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].objet = s_objet_2;
}
else
{
if ((s_variable.nom = malloc((strlen((((struct_nom )
(s_objet_1).objet)).nom) + 1) sizeof(unsigned char)))
== NULL)
{
(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;
return;
}

strcpy(s_variable.nom, (((struct_nom )
(*s_objet_1).objet)).nom);
s_variable.niveau = 1;

/*
* Le niveau 0 correspond aux définitions. Les variables
* commencent à 1 car elles sont toujours incluses dans
* une définition.
*/

s_variable.objet = s_objet_2;

if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')	(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
== d_erreur)	return;
{
return;
}
}
}	}

	liberation(s_etat_processus,
	((s_etat_processus).pointeur_variable_courante).objet);
	((s_etat_processus).pointeur_variable_courante).objet = s_objet_2;
}	}
else	else
{	{
Line 964 instruction_suspend(struct_processus *s_	Line 862 instruction_suspend(struct_processus *s_
return;	return;
}	}

	if (sigdelset(&masque, SIGFABORT) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

if (sigdelset(&masque, SIGURG) != 0)	if (sigdelset(&masque, SIGURG) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 986 instruction_suspend(struct_processus *s_	Line 890 instruction_suspend(struct_processus *s_
}	}
}	}

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

sigsuspend(&masque);	sigsuspend(&masque);

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1359 instruction_swi(struct_processus *s_etat	Line 1275 instruction_swi(struct_processus *s_etat
attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_etat_processus).pipe_nombre_objets_attente,	(*s_etat_processus).pipe_nombre_objets_attente,
&pid, sizeof(pid))) != sizeof(pid))	&pid, sizeof(pid))) != sizeof(pid))
{	{
	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1400 instruction_swi(struct_processus *s_etat	Line 1328 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1423 instruction_swi(struct_processus *s_etat	Line 1359 instruction_swi(struct_processus *s_etat
attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_etat_processus).pipe_nombre_objets_attente,	(*s_etat_processus).pipe_nombre_objets_attente,
&tid, sizeof(tid))) != sizeof(tid))	&tid, sizeof(tid))) != sizeof(tid))
{	{
	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1464 instruction_swi(struct_processus *s_etat	Line 1412 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif
}	}

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1486 instruction_swi(struct_processus *s_etat	Line 1446 instruction_swi(struct_processus *s_etat
attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_etat_processus).pipe_interruptions,	(*s_etat_processus).pipe_interruptions,
&interruption_reduite, sizeof(interruption_reduite)))	&interruption_reduite, sizeof(interruption_reduite)))
!= sizeof(interruption_reduite))	!= sizeof(interruption_reduite))
{	{
	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1528 instruction_swi(struct_processus *s_etat	Line 1500 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif
}	}

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1551 instruction_swi(struct_processus *s_etat	Line 1535 instruction_swi(struct_processus *s_etat
attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_etat_processus).pipe_nombre_interruptions_attente,	(*s_etat_processus).pipe_nombre_interruptions_attente,
&pid, sizeof(pid))) != sizeof(pid))	&pid, sizeof(pid))) != sizeof(pid))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork))	# ifndef SEMAPHORES_NOMMES
== -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1590 instruction_swi(struct_processus *s_etat	Line 1585 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif
}	}

pid = getpid();	pid = getpid();
Line 1606 instruction_swi(struct_processus *s_etat	Line 1609 instruction_swi(struct_processus *s_etat
(*s_etat_processus).pipe_nombre_interruptions_attente,	(*s_etat_processus).pipe_nombre_interruptions_attente,
&pid, sizeof(pid))) != sizeof(pid))	&pid, sizeof(pid))) != sizeof(pid))
{	{
	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1637 instruction_swi(struct_processus *s_etat	Line 1644 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif
}	}

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1657 instruction_swi(struct_processus *s_etat	Line 1676 instruction_swi(struct_processus *s_etat
{	{
tid = -3;	tid = -3;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_etat_processus).pipe_nombre_interruptions_attente,	(*s_etat_processus).pipe_nombre_interruptions_attente,
&tid, sizeof(tid))) != sizeof(tid))	&tid, sizeof(tid))) != sizeof(tid))
{	{
	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1698 instruction_swi(struct_processus *s_etat	Line 1729 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif
}	}

tid = pthread_self();	tid = pthread_self();
Line 1714 instruction_swi(struct_processus *s_etat	Line 1753 instruction_swi(struct_processus *s_etat
(*s_etat_processus).pipe_nombre_interruptions_attente,	(*s_etat_processus).pipe_nombre_interruptions_attente,
&tid, sizeof(tid))) != sizeof(tid))	&tid, sizeof(tid))) != sizeof(tid))
{	{
	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1746 instruction_swi(struct_processus *s_etat	Line 1789 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif
}	}

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1766 instruction_swi(struct_processus *s_etat	Line 1821 instruction_swi(struct_processus *s_etat
attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	# endif

while(read_atomic(s_etat_processus,	while(read_atomic(s_etat_processus,
(*s_etat_processus).pipe_acquittement,	(*s_etat_processus).pipe_acquittement,
&tampon, sizeof(unsigned char)) != sizeof(unsigned char))	&tampon, sizeof(unsigned char)) != sizeof(unsigned char))
{	{
	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{
Line 1788 instruction_swi(struct_processus *s_etat	Line 1855 instruction_swi(struct_processus *s_etat
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);

	# ifndef SEMAPHORES_NOMMES
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	if (sem_post((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
}	}

	# ifndef SEMAPHORES_NOMMES
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
	# endif
{	{
if (errno != EINTR)	if (errno != EINTR)
{	{

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.3
changed lines
	Added in v.1.28