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.20 and 1.40

version 1.20, 2010/08/26 19:07:40	version 1.40, 2011/09/20 08:56:24
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.19	RPL/2 (R) version 4.1.3
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 141 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 152 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 163 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 234 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).s_liste_variables
[(*s_etat_processus).position_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 252 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 265 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 663 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 738 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;
return;
}

liberation(s_etat_processus,	(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
(s_etat_processus).s_liste_variables[(s_etat_processus)	return;
.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--;
}

if (presence_variable == d_vrai)
{
(*s_etat_processus).position_variable_courante = i;
}
else
{
(*s_etat_processus).position_variable_courante = 0;
}

if (((s_etat_processus).s_liste_variables[(s_etat_processus)
.position_variable_courante].niveau == 1) &&
(presence_variable == d_vrai))
{
// 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,	if (((s_etat_processus).pointeur_variable_courante).objet == NULL)
(*s_etat_processus).s_liste_variables	{
[(*s_etat_processus).position_variable_courante].objet);	liberation(s_etat_processus, s_objet_1);
	liberation(s_etat_processus, s_objet_2);
(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 930 instruction_save(struct_processus *s_eta	Line 809 instruction_save(struct_processus *s_eta
void	void
instruction_suspend(struct_processus *s_etat_processus)	instruction_suspend(struct_processus *s_etat_processus)
{	{
sigset_t masque;	struct timespec attente;

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

Line 940 instruction_suspend(struct_processus *s_	Line 819 instruction_suspend(struct_processus *s_

if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
printf("(attend un signal SIGCONT)\n\n");	printf("(attend un signal RPL/SIGCONT)\n\n");
printf(" Aucun argument\n");	printf(" Aucun argument\n");
}	}
else	else
{	{
printf("(wait for SIGCONT signal)\n\n");	printf("(wait for RPL/SIGCONT signal)\n\n");
printf(" No argument\n");	printf(" No argument\n");
}	}

Line 965 instruction_suspend(struct_processus *s_	Line 844 instruction_suspend(struct_processus *s_
}	}
}	}

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

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

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

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

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

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

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
{	{
profilage(s_etat_processus, "Suspend");	profilage(s_etat_processus, "Suspend");
Line 1011 instruction_suspend(struct_processus *s_	Line 854 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);

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

	if ((*s_etat_processus).redemarrage_processus == d_vrai)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	break;
return;
}	}

	nanosleep(&attente, NULL);
	INCR_GRANULARITE(attente.tv_nsec);
	}

	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
}	}

if ((*s_etat_processus).profilage == d_vrai)	if ((*s_etat_processus).profilage == d_vrai)
Line 1396 instruction_swi(struct_processus *s_etat	Line 1235 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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
Line 1449 instruction_swi(struct_processus *s_etat	Line 1273 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))
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	!= 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	scrutation_interruptions(s_etat_processus);
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}
}	}
else	else
Line 1480 instruction_swi(struct_processus *s_etat	Line 1296 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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
Line 1533 instruction_swi(struct_processus *s_etat	Line 1334 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	scrutation_interruptions(s_etat_processus);
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}
}	}

Line 1567 instruction_swi(struct_processus *s_etat	Line 1355 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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
Line 1621 instruction_swi(struct_processus *s_etat	Line 1394 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)	scrutation_interruptions(s_etat_processus);
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
# endif
}	}

# ifndef SEMAPHORES_NOMMES	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if ((*s_etat_processus).processus_detache == d_vrai)	if ((*s_etat_processus).processus_detache == d_vrai)
Line 1656 instruction_swi(struct_processus *s_etat	Line 1416 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))
{	{
# ifndef SEMAPHORES_NOMMES	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
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 1706 instruction_swi(struct_processus *s_etat	Line 1454 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)	scrutation_interruptions(s_etat_processus);
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
# endif
}	}

pid = getpid();	pid = getpid();
Line 1730 instruction_swi(struct_processus *s_etat	Line 1472 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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
Line 1765 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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

kill((*s_etat_processus).pid_processus_pere, SIGCONT);
}	}
else	else
{	{
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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
Line 1852 instruction_swi(struct_processus *s_etat	Line 1555 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)	scrutation_interruptions(s_etat_processus);
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
# endif
}	}

tid = pthread_self();	tid = pthread_self();
Line 1876 instruction_swi(struct_processus *s_etat	Line 1573 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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
Line 1912 instruction_swi(struct_processus *s_etat	Line 1602 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)	scrutation_interruptions(s_etat_processus);
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
# endif
}	}

# ifndef SEMAPHORES_NOMMES	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

pthread_kill((*s_etat_processus).tid_processus_pere, SIGCONT);
}	}

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	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

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;
}	}

	scrutation_interruptions(s_etat_processus);
}	}

# ifndef SEMAPHORES_NOMMES	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
# else
while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
# endif
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}

if (registre == 0)	if (registre == 0)

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.20
changed lines
	Added in v.1.40