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.40

version 1.3, 2010/02/10 10:14:25	version 1.40, 2011/09/20 08:56:24
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.11	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 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 =	(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
d_ex_variable_verrouillee;	return;
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
{
// On cherche une variable globale de même nom.

i = (*s_etat_processus).position_variable_courante;	if (((s_etat_processus).pointeur_variable_courante).objet == NULL)
presence_variable = d_faux;	{
	liberation(s_etat_processus, s_objet_1);
while(i >= 0)	liberation(s_etat_processus, s_objet_2);
{
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).s_liste_variables[(s_etat_processus)
.position_variable_courante].niveau == 1)
{
// 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 911 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 921 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 946 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, 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 992 instruction_suspend(struct_processus *s_	Line 860 instruction_suspend(struct_processus *s_
return;	return;
}	}

sigsuspend(&masque);	for((*s_etat_processus).redemarrage_processus = d_faux;;)

while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
{	{
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 1369 instruction_swi(struct_processus *s_etat	Line 1245 instruction_swi(struct_processus *s_etat
(*s_etat_processus).pipe_nombre_objets_attente,	(*s_etat_processus).pipe_nombre_objets_attente,
&pid, sizeof(pid))) != sizeof(pid))	&pid, sizeof(pid))) != sizeof(pid))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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 1400 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);

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

while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	scrutation_interruptions(s_etat_processus);

	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
if (errno != EINTR)	(*s_etat_processus).erreur_systeme = d_es_processus;
{	return;
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}
}	}
}	}
else	else
Line 1433 instruction_swi(struct_processus *s_etat	Line 1306 instruction_swi(struct_processus *s_etat
(*s_etat_processus).pipe_nombre_objets_attente,	(*s_etat_processus).pipe_nombre_objets_attente,
&tid, sizeof(tid))) != sizeof(tid))	&tid, sizeof(tid))) != sizeof(tid))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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 1471 instruction_swi(struct_processus *s_etat	Line 1341 instruction_swi(struct_processus *s_etat
}	}
}	}

while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	scrutation_interruptions(s_etat_processus);

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

Line 1497 instruction_swi(struct_processus *s_etat	Line 1366 instruction_swi(struct_processus *s_etat
&interruption_reduite, sizeof(interruption_reduite)))	&interruption_reduite, sizeof(interruption_reduite)))
!= sizeof(interruption_reduite))	!= sizeof(interruption_reduite))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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 1399 instruction_swi(struct_processus *s_etat
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

	scrutation_interruptions(s_etat_processus);
}	}

while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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 1561 instruction_swi(struct_processus *s_etat	Line 1426 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))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork))	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
== -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
Line 1595 instruction_swi(struct_processus *s_etat	Line 1459 instruction_swi(struct_processus *s_etat
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

	scrutation_interruptions(s_etat_processus);
}	}

pid = getpid();	pid = getpid();
Line 1606 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))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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 1644 instruction_swi(struct_processus *s_etat	Line 1507 instruction_swi(struct_processus *s_etat
}	}
}	}

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

	scrutation_interruptions(s_etat_processus);
}	}

tid = pthread_self();	tid = pthread_self();
Line 1714 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))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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 1751 instruction_swi(struct_processus *s_etat	Line 1607 instruction_swi(struct_processus *s_etat
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

	scrutation_interruptions(s_etat_processus);
}	}

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

Line 1776 instruction_swi(struct_processus *s_etat	Line 1631 instruction_swi(struct_processus *s_etat
(*s_etat_processus).pipe_acquittement,	(*s_etat_processus).pipe_acquittement,
&tampon, sizeof(unsigned char)) != sizeof(unsigned char))	&tampon, sizeof(unsigned char)) != sizeof(unsigned char))
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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);
Line 1793 instruction_swi(struct_processus *s_etat	Line 1645 instruction_swi(struct_processus *s_etat
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

	scrutation_interruptions(s_etat_processus);
}	}

while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)	if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
{	{
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.3
changed lines
	Added in v.1.40