rpl/src/instructions_s1.c - diff

Return to instructions_s1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_s1.c between versions 1.39 and 1.110

version 1.39, 2011/09/20 08:56:23	version 1.110, 2019/07/16 15:17:00
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.3	RPL/2 (R) version 4.1.31
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2019 Dr. BERTRAND Joël

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

Line 19	Line 19
================================================================================	================================================================================
*/	*/

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


Line 59 instruction_swap(struct_processus *s_eta	Line 59 instruction_swap(struct_processus *s_eta
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s\n",	" %s, %s\n",
d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,	d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,	d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
d_SLB, d_PRC, d_MTX, d_SQL);	d_SLB, d_PRC, d_MTX, d_SQL, d_REC);
printf(" 1: %s, %s, %s, %s, %s, %s,\n"	printf(" 1: %s, %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s\n",	" %s, %s\n",
d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,	d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,	d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
d_SLB, d_PRC, d_MTX, d_SQL);	d_SLB, d_PRC, d_MTX, d_SQL, d_REC);
printf("-> 2: %s, %s, %s, %s, %s, %s,\n"	printf("-> 2: %s, %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s\n",	" %s, %s\n",
d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,	d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,	d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
d_SLB, d_PRC, d_MTX, d_SQL);	d_SLB, d_PRC, d_MTX, d_SQL, d_REC);
printf(" 1: %s, %s, %s, %s, %s, %s,\n"	printf(" 1: %s, %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s\n",	" %s, %s\n",
d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,	d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,	d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
d_SLB, d_PRC, d_MTX, d_SQL);	d_SLB, d_PRC, d_MTX, d_SQL, d_REC);

return;	return;
}	}
Line 147 instruction_sq(struct_processus *s_etat_	Line 147 instruction_sq(struct_processus *s_etat_
struct_objet *s_objet_argument;	struct_objet *s_objet_argument;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;

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

void *accumulateur;	void *accumulateur;

Line 310 instruction_sq(struct_processus *s_etat_	Line 310 instruction_sq(struct_processus *s_etat_
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(integer8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 323 instruction_sq(struct_processus *s_etat_	Line 323 instruction_sq(struct_processus *s_etat_
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(integer8))) == NULL)	.objet))).nombre_colonnes) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 366 instruction_sq(struct_processus *s_etat_	Line 366 instruction_sq(struct_processus *s_etat_
(*s_objet_resultat).type = MRL;	(*s_objet_resultat).type = MRL;
(((struct_matrice ) (*s_objet_resultat).objet)).type = 'R';	(((struct_matrice ) (*s_objet_resultat).objet)).type = 'R';

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument).objet))).nombre_colonnes	(s_objet_argument).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 381 instruction_sq(struct_processus *s_etat_	Line 381 instruction_sq(struct_processus *s_etat_
(*s_objet_resultat).objet)).tableau)[i]);	(*s_objet_resultat).objet)).tableau)[i]);

if (((((struct_matrice ) (*s_objet_resultat).objet))	if (((((struct_matrice ) (*s_objet_resultat).objet))
.tableau[i] = malloc(((((struct_matrice )	.tableau[i] = malloc(((size_t) ((((struct_matrice )
(s_objet_resultat).objet))).nombre_colonnes	(s_objet_resultat).objet))).nombre_colonnes)
sizeof(real8))) == NULL)	sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 457 instruction_sq(struct_processus *s_etat_	Line 457 instruction_sq(struct_processus *s_etat_
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(real8 *))) == NULL)	.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument).objet))).nombre_colonnes sizeof(real8)))	(s_objet_argument).objet))).nombre_colonnes) sizeof(real8)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 476 instruction_sq(struct_processus *s_etat_	Line 476 instruction_sq(struct_processus *s_etat_
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(real8))) == NULL)	.objet))).nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 549 instruction_sq(struct_processus *s_etat_	Line 549 instruction_sq(struct_processus *s_etat_
.objet))).nombre_colonnes;	.objet))).nombre_colonnes;

if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)	.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if ((accumulateur = malloc(((((struct_matrice )	if ((accumulateur = malloc(((size_t) ((((struct_matrice )
(s_objet_argument).objet))).nombre_colonnes	(s_objet_argument).objet))).nombre_colonnes)
sizeof(complex16))) == NULL)	sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 568 instruction_sq(struct_processus *s_etat_	Line 569 instruction_sq(struct_processus *s_etat_
.objet))).nombre_lignes; i++)	.objet))).nombre_lignes; i++)
{	{
if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =	if (((((struct_matrice ) (*s_objet_resultat).objet)).tableau[i] =
malloc(((((struct_matrice ) (*s_objet_resultat)	malloc(((size_t) ((((struct_matrice ) (*s_objet_resultat)
.objet))).nombre_colonnes * sizeof(struct_complexe16)))	.objet))).nombre_colonnes) * sizeof(struct_complexe16)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1216 instruction_same(struct_processus *s_eta	Line 1217 instruction_same(struct_processus *s_eta

logical1 difference;	logical1 difference;

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

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

Line 2572 instruction_start(struct_processus *s_et	Line 2573 instruction_start(struct_processus *s_et
}	}
}	}

empilement_pile_systeme(s_etat_processus);

if ((*s_etat_processus).erreur_systeme != d_es)
{
return;
}

((s_etat_processus).l_base_pile_systeme).type_cloture = 'S';

if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
&s_objet_1) == d_erreur)	&s_objet_1) == d_erreur)
{	{
Line 2614 instruction_start(struct_processus *s_et	Line 2606 instruction_start(struct_processus *s_et
return;	return;
}	}

	empilement_pile_systeme(s_etat_processus);

	if ((*s_etat_processus).erreur_systeme != d_es)
	{
	return;
	}

	((s_etat_processus).l_base_pile_systeme).type_cloture = 'S';

((s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet_2;	((s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet_2;
((s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;	((s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;

Line 2916 instruction_step(struct_processus *s_eta	Line 2917 instruction_step(struct_processus *s_eta
{	{
(*s_etat_processus).niveau_courant--;	(*s_etat_processus).niveau_courant--;

if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)	if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
{	{
return;	return;
}	}
Line 3088 instruction_stof(struct_processus *s_eta	Line 3089 instruction_stof(struct_processus *s_eta

for(i = 1; i <= 64; i++)	for(i = 1; i <= 64; i++)
{	{
indice_drapeau = i - 1;	indice_drapeau = (unsigned char) (i - 1);
indice_bloc = indice_drapeau / taille_bloc;	indice_bloc = indice_drapeau / taille_bloc;
indice_bit = indice_drapeau % taille_bloc;	indice_bit = indice_drapeau % taille_bloc;
masque = ((t_8_bits) 1) << (taille_bloc - indice_bit - 1);	masque = (t_8_bits) (((t_8_bits) 1) <<
	(taille_bloc - indice_bit - 1));

if (((((logical8 ) (*s_objet).objet)) &	if (((((logical8 ) (*s_objet).objet)) &
((logical8) 1) << indice_drapeau) != 0)	((logical8) 1) << indice_drapeau) != 0)
Line 3153 instruction_sto(struct_processus *s_etat	Line 3155 instruction_sto(struct_processus *s_etat
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s, %s, %s, %s, %s,\n"	" %s, %s, %s, %s, %s,\n"
" %s\n",	" %s, %s\n",
d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,	d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,	d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
d_SLB, d_PRC, d_MTX, d_SQL);	d_SLB, d_PRC, d_MTX, d_SQL, d_REC);
printf(" 1: %s\n", d_NOM);	printf(" 1: %s\n", d_NOM);

return;	return;
Line 3219 instruction_sto(struct_processus *s_etat	Line 3221 instruction_sto(struct_processus *s_etat

if (((s_etat_processus).pointeur_variable_courante).objet == NULL)	if (((s_etat_processus).pointeur_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).pointeur_variable_courante).nom,	((s_etat_processus).pointeur_variable_courante).nom,
((s_etat_processus).pointeur_variable_courante)	((s_etat_processus).pointeur_variable_courante)
.variable_partagee, ((s_etat_processus)	.variable_partagee, ((s_etat_processus)
.pointeur_variable_courante).origine) == d_faux)	.pointeur_variable_courante).origine) == NULL)
{	{
if (pthread_mutex_unlock(&(((s_etat_processus)	if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
.s_liste_variables_partagees).mutex)) != 0)	((((struct_nom ) (*s_objet_1).objet)).symbole
{	== d_faux))
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

if ((*s_etat_processus).autorisation_nom_implicite == 'N')
{	{
liberation(s_etat_processus, s_objet_1);	liberation(s_etat_processus, s_objet_1);
liberation(s_etat_processus, s_objet_2);	liberation(s_etat_processus, s_objet_2);
Line 3282 instruction_sto(struct_processus *s_etat	Line 3272 instruction_sto(struct_processus *s_etat
else	else
{	{
liberation(s_etat_processus, ((s_etat_processus)	liberation(s_etat_processus, ((s_etat_processus)
.s_liste_variables_partagees).table	.pointeur_variable_partagee_courante).objet);
[((s_etat_processus).s_liste_variables_partagees)	((s_etat_processus).pointeur_variable_partagee_courante)
.position_variable].objet);	.objet = s_objet_2;

((s_etat_processus).s_liste_variables_partagees).table
[((s_etat_processus).s_liste_variables_partagees)
.position_variable].objet = s_objet_2;

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 3300 instruction_sto(struct_processus *s_etat	Line 3286 instruction_sto(struct_processus *s_etat
}	}
else	else
{	{
if ((*s_etat_processus).autorisation_nom_implicite == 'N')	if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
	((((struct_nom ) (*s_objet_1).objet)).symbole == d_faux))
{	{
if (((s_etat_processus).pointeur_variable_courante)	if (((s_etat_processus).pointeur_variable_courante)
.niveau == 1)	.niveau == 1)
Line 3327 instruction_sto(struct_processus *s_etat	Line 3314 instruction_sto(struct_processus *s_etat
* une variable globale.	* une variable globale.
*/	*/

if ((*s_etat_processus).autorisation_nom_implicite == 'N')	if (((*s_etat_processus).autorisation_nom_implicite == 'N') &&
	((((struct_nom ) (*s_objet_1).objet)).symbole == d_faux))
{	{
liberation(s_etat_processus, s_objet_1);	liberation(s_etat_processus, s_objet_1);
liberation(s_etat_processus, s_objet_2);	liberation(s_etat_processus, s_objet_2);
Line 3384 instruction_sto(struct_processus *s_etat	Line 3372 instruction_sto(struct_processus *s_etat
================================================================================	================================================================================
*/	*/

	static struct
	{
	struct_processus *s_etat_processus;
	struct_liste_chainee *fd_stdin;
	int pipe_entree;
	volatile int erreur;
	} arguments_stdin;

	static void *
	thread_stdin(void *argument)
	{
	integer8 longueur_ecriture;

	typeof(arguments_stdin) *ptr;

	struct_liste_chainee *l_element_courant;

	struct_processus *s_etat_processus;

	unsigned char *ligne;

	ptr = argument;

	l_element_courant = (*ptr).fd_stdin;
	s_etat_processus = (*ptr).s_etat_processus;
	(*ptr).erreur = d_es;

	while(l_element_courant != NULL)
	{
	if ((ligne = formateur_flux(s_etat_processus,
	(unsigned char ) ((*l_element_courant).donnee).objet,
	&longueur_ecriture)) == NULL)
	{
	(*ptr).erreur = d_es_allocation_memoire;
	close((*ptr).pipe_entree);
	pthread_exit(NULL);
	}

	while(write_atomic(s_etat_processus, (*ptr).pipe_entree, ligne,
	(size_t) longueur_ecriture) != longueur_ecriture)
	{
	if (longueur_ecriture == -1)
	{
	(*ptr).erreur = d_es_processus;
	close((*ptr).pipe_entree);
	pthread_exit(NULL);
	}
	}

	free(ligne);

	while(write_atomic(s_etat_processus, (*ptr).pipe_entree, "\n", 1)
	!= 1)
	{
	if (longueur_ecriture == -1)
	{
	(*ptr).erreur = d_es_processus;
	close((*ptr).pipe_entree);
	pthread_exit(NULL);
	}
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	if (close((*ptr).pipe_entree) != 0)
	{
	(*ptr).erreur = d_es_processus;
	}
	else
	{
	(*ptr).erreur = d_es;
	}

	pthread_exit(NULL);
	}

void	void
instruction_syseval(struct_processus *s_etat_processus)	instruction_syseval(struct_processus *s_etat_processus)
{	{
char **arguments;	char **arguments;

	int etape;
int ios;	int ios;
int pipes_entree[2];	int pipes_entree[2];
int pipes_erreur[2];	int pipes_erreur[2];
int pipes_sortie[2];	int pipes_sortie[2];
	int registre_ios;
int status;	int status;

	file *fpipe;

logical1 drapeau_fin;	logical1 drapeau_fin;
logical1 presence_stdin;	logical1 presence_stdin;

Line 3403 instruction_syseval(struct_processus *s_	Line 3472 instruction_syseval(struct_processus *s_

pid_t pid;	pid_t pid;

ssize_t longueur_ecriture;	pthread_attr_t attributs;

	pthread_t thread_stdin_tid;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_precedent;	struct_liste_chainee *l_element_precedent;
Line 3417 instruction_syseval(struct_processus *s_	Line 3488 instruction_syseval(struct_processus *s_
struct sigaction action_courante;	struct sigaction action_courante;
struct sigaction action_passee;	struct sigaction action_passee;

	struct timespec attente;

	struct timeval horodatage_final;
	struct timeval horodatage_initial;

unsigned char *ptr;	unsigned char *ptr;
unsigned char *ptr2;	unsigned char *ptr2;
unsigned char registre_autorisation_empilement_programme;	unsigned char registre_autorisation_empilement_programme;
Line 3424 instruction_syseval(struct_processus *s_	Line 3500 instruction_syseval(struct_processus *s_
unsigned char *registre_programme;	unsigned char *registre_programme;
unsigned char *tampon;	unsigned char *tampon;

unsigned long longueur_lecture;	integer8 longueur_lecture;
unsigned long longueur_tampon;	integer8 longueur_lue;
unsigned long nombre_iterations;	integer8 longueur_tampon;
unsigned long nombre_lignes;	integer8 longueur_traitee;
unsigned long pointeur;	integer8 nombre_lignes;
unsigned long registre_position_courante;	integer8 pointeur;
	integer8 registre_position_courante;

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

Line 3523 instruction_syseval(struct_processus *s_	Line 3600 instruction_syseval(struct_processus *s_
registre_programme = (*s_etat_processus).definitions_chainees;	registre_programme = (*s_etat_processus).definitions_chainees;
registre_position_courante = (*s_etat_processus).position_courante;	registre_position_courante = (*s_etat_processus).position_courante;

(*s_etat_processus).definitions_chainees =
(unsigned char ) (s_objet).objet;
(*s_etat_processus).position_courante = 0;	(*s_etat_processus).position_courante = 0;
(*s_etat_processus).autorisation_empilement_programme = 'N';	(*s_etat_processus).autorisation_empilement_programme = 'N';

Line 3532 instruction_syseval(struct_processus *s_	Line 3607 instruction_syseval(struct_processus *s_
* Échappement des guillemets	* Échappement des guillemets
*/	*/

ptr = (*s_etat_processus).definitions_chainees;	if (((*s_etat_processus).definitions_chainees =
ptr2 = ptr;	formateur_flux(s_etat_processus, (unsigned char *)
i = 0;	(*s_objet).objet, &longueur_traitee)) == NULL)

while((*ptr) != d_code_fin_chaine)
{	{
if ((*ptr) == '\\')	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
{	return;
switch (*(ptr + 1))
{
case '"':
case '\\':
{
ptr++;
break;
}
}
}

ptr2++ = ptr++;
}	}

*ptr2 = d_code_fin_chaine;

/*	/*
* Scission de la chaîne en différents arguments	* Scission de la chaîne en différents arguments
*/	*/
Line 3567 instruction_syseval(struct_processus *s_	Line 3626 instruction_syseval(struct_processus *s_
{	{
if (recherche_instruction_suivante(s_etat_processus) == d_erreur)	if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
{	{
	free((*s_etat_processus).definitions_chainees);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre_autorisation_empilement_programme;	registre_autorisation_empilement_programme;
(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
Line 3584 instruction_syseval(struct_processus *s_	Line 3645 instruction_syseval(struct_processus *s_
if ((s_objet_temporaire = allocation(s_etat_processus, CHN))	if ((s_objet_temporaire = allocation(s_etat_processus, CHN))
== NULL)	== NULL)
{	{
	free((*s_etat_processus).definitions_chainees);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre_autorisation_empilement_programme;	registre_autorisation_empilement_programme;
(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
Line 3628 instruction_syseval(struct_processus *s_	Line 3691 instruction_syseval(struct_processus *s_
&((*s_etat_processus).l_base_pile),	&((*s_etat_processus).l_base_pile),
s_objet_temporaire) == d_erreur)	s_objet_temporaire) == d_erreur)
{	{
	free((*s_etat_processus).definitions_chainees);

	(*s_etat_processus).autorisation_empilement_programme =
	registre_autorisation_empilement_programme;
	(*s_etat_processus).instruction_courante =
	registre_instruction_courante;
	(*s_etat_processus).definitions_chainees =
	registre_programme;
	(*s_etat_processus).position_courante =
	registre_position_courante;
return;	return;
}	}
}	}
Line 3640 instruction_syseval(struct_processus *s_	Line 3713 instruction_syseval(struct_processus *s_
nombre_arguments++;	nombre_arguments++;
} while(drapeau_fin == d_faux);	} while(drapeau_fin == d_faux);

	free((*s_etat_processus).definitions_chainees);

(*s_etat_processus).autorisation_empilement_programme =	(*s_etat_processus).autorisation_empilement_programme =
registre_autorisation_empilement_programme;	registre_autorisation_empilement_programme;
(*s_etat_processus).instruction_courante =	(*s_etat_processus).instruction_courante =
Line 3647 instruction_syseval(struct_processus *s_	Line 3722 instruction_syseval(struct_processus *s_
(*s_etat_processus).definitions_chainees = registre_programme;	(*s_etat_processus).definitions_chainees = registre_programme;
(*s_etat_processus).position_courante = registre_position_courante;	(*s_etat_processus).position_courante = registre_position_courante;

if ((arguments = malloc(nombre_arguments * sizeof(char *))) == NULL)	if ((arguments = malloc(((size_t) nombre_arguments) * sizeof(char *)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
Line 3662 instruction_syseval(struct_processus *s_	Line 3738 instruction_syseval(struct_processus *s_
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
}	}

action_courante.sa_handler = SIG_IGN;
action_courante.sa_flags = SA_NODEFER \| SA_ONSTACK;

if (sigaction(SIGINT, &action_courante, &action_passee) != 0)
{
for(i = 0; i < nombre_arguments; i++)
{
depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
&s_objet_temporaire);
liberation(s_etat_processus, s_objet_temporaire);
}

free(arguments);
(*s_etat_processus).erreur_systeme = d_es_signal;
return;
}

if (pipe(pipes_entree) != 0)	if (pipe(pipes_entree) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
Line 3699 instruction_syseval(struct_processus *s_	Line 3758 instruction_syseval(struct_processus *s_

fflush(NULL);	fflush(NULL);

	attente.tv_sec = 0;
	attente.tv_nsec = GRANULARITE_us * 1000;

	while(pthread_mutex_trylock(&mutex_sigaction) != 0)
	{
	# ifndef SEMAPHORES_NOMMES
	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;
	return;
	}

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

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

	action_courante.sa_handler = SIG_IGN;
	action_courante.sa_flags = 0;

	if (sigaction(SIGINT, &action_courante, &action_passee) != 0)
	{
	for(i = 0; i < nombre_arguments; i++)
	{
	depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
	&s_objet_temporaire);
	liberation(s_etat_processus, s_objet_temporaire);
	}

	free(arguments);
	(*s_etat_processus).erreur_systeme = d_es_signal;
	return;
	}

verrouillage_threads_concurrents(s_etat_processus);	verrouillage_threads_concurrents(s_etat_processus);

pid = fork();	pid = fork();
deverrouillage_threads_concurrents(s_etat_processus);

if (pid < 0)	if (pid < 0)
{	{
Line 3746 instruction_syseval(struct_processus *s_	Line 3851 instruction_syseval(struct_processus *s_
}	}
else if (pid == 0)	else if (pid == 0)
{	{
	(*s_etat_processus).erreur_systeme = d_es;

if (close(pipes_entree[1]) != 0)	if (close(pipes_entree[1]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	printf("%d\n",__LINE__);
}	}

if (close(pipes_sortie[0]) != 0)	if (close(pipes_sortie[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	printf("%d\n",__LINE__);
}	}

if (close(pipes_erreur[0]) != 0)	if (close(pipes_erreur[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	printf("%d\n",__LINE__);
}	}

if (pipes_entree[0] != STDIN_FILENO)	if (pipes_entree[0] != STDIN_FILENO)
Line 3769 instruction_syseval(struct_processus *s_	Line 3876 instruction_syseval(struct_processus *s_
if (dup2(pipes_entree[0], STDIN_FILENO) == -1)	if (dup2(pipes_entree[0], STDIN_FILENO) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	printf("%d\n",__LINE__);
}	}
}	}

Line 3778 instruction_syseval(struct_processus *s_	Line 3885 instruction_syseval(struct_processus *s_
if (dup2(pipes_sortie[1], STDOUT_FILENO) == -1)	if (dup2(pipes_sortie[1], STDOUT_FILENO) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	printf("%d\n",__LINE__);
}	}
}	}

Line 3787 instruction_syseval(struct_processus *s_	Line 3894 instruction_syseval(struct_processus *s_
if (dup2(pipes_sortie[1], STDERR_FILENO) == -1)	if (dup2(pipes_sortie[1], STDERR_FILENO) == -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	printf("%d\n",__LINE__);
}	}
}	}

if (nombre_arguments != 0)	if ((nombre_arguments != 0) && ((*s_etat_processus).erreur_systeme
	== d_es))
{	{
execvp(arguments[0], arguments);	execvp(arguments[0], arguments);
}	}
else
{
exit(EXIT_SUCCESS);
}

/*	/*
* L'appel système execvp() a généré une erreur et n'a pu exécuter	* L'appel système execvp() a généré une erreur et n'a pu exécuter
Line 3827 instruction_syseval(struct_processus *s_	Line 3931 instruction_syseval(struct_processus *s_
write_atomic(s_etat_processus, pipes_erreur[1], " ", 1);	write_atomic(s_etat_processus, pipes_erreur[1], " ", 1);
close(pipes_erreur[1]);	close(pipes_erreur[1]);

	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Système : erreur interne dans SYSEVAL [%d]\n",
	(int) getpid());
	}
	else
	{
	printf("+++System : SYSEVAL internal error [%d]\n",
	(int) getpid());
	}

exit(EXIT_SUCCESS);	exit(EXIT_SUCCESS);
}	}
else	else
{	{
if (close(pipes_entree[0]) != 0)	if (sigaction(SIGINT, &action_passee, NULL) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	for(i = 0; i < nombre_arguments; i++)
	{
	depilement(s_etat_processus,
	&((*s_etat_processus).l_base_pile),
	&s_objet_temporaire);
	liberation(s_etat_processus, s_objet_temporaire);
	}

	free(arguments);
	(*s_etat_processus).erreur_systeme = d_es_signal;
return;	return;
}	}

if (close(pipes_sortie[1]) != 0)	if (pthread_mutex_unlock(&mutex_sigaction) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (close(pipes_erreur[1]) != 0)	deverrouillage_threads_concurrents(s_etat_processus);

	if (close(pipes_entree[0]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (presence_stdin == d_vrai)	if (close(pipes_sortie[1]) != 0)
{	{
l_element_courant = l_element_stdin;	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
while(l_element_courant != NULL)
{
longueur_ecriture = strlen((unsigned char *)
((l_element_courant).donnee).objet);

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

while(write_atomic(s_etat_processus,
pipes_entree[1], (unsigned char *)
((l_element_courant).donnee).objet,
longueur_ecriture) != longueur_ecriture)
{
while(sem_wait(&((*s_etat_processus)
.semaphore_fork)) != 0)
{
(*s_etat_processus).erreur_systeme =
d_es_processus;
return;
}

if (longueur_ecriture == -1)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

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

while(write_atomic(s_etat_processus,
pipes_entree[1], "\n", 1) != 1)
{
if (sem_wait(&((*s_etat_processus)
.semaphore_fork)) != 0)
{
(*s_etat_processus).erreur_systeme =
d_es_processus;
return;
}

if (longueur_ecriture == -1)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

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

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

l_element_courant = (*l_element_courant).suivant;
}
}	}

if (close(pipes_entree[1]) != 0)	if (close(pipes_erreur[1]) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

do	if (presence_stdin == d_vrai)
{	{
if (kill(pid, 0) != 0)	// L'écriture sur stdin est dans un thread séparé pour
	// ne pas bloquer.

	if (pthread_attr_init(&attributs) != 0)
{	{
break;	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
}	}

/*	if (pthread_attr_setdetachstate(&attributs,
* Récupération de la valeur de retour du processus détaché	PTHREAD_CREATE_JOINABLE) != 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;
}	}

if (waitpid(pid, &status, 0) == -1)	arguments_stdin.s_etat_processus = s_etat_processus;
{	arguments_stdin.fd_stdin = l_element_stdin;
if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	arguments_stdin.pipe_entree = pipes_entree[1];
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return;
}

	if (pthread_create(&thread_stdin_tid, &attributs, thread_stdin,
	&arguments_stdin) != 0)
	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)	if (pthread_attr_destroy(&attributs) != 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
} while((!WIFEXITED(status)) && (!WIFSIGNALED(status)));	}

longueur_lecture = 256;	longueur_lecture = 65536;
	longueur_lue = 0;
pointeur = 0;	pointeur = 0;
nombre_iterations = 1;

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

if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	tampon[0] = d_code_fin_chaine;

	# ifndef SEMAPHORES_NOMMES
	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;
}	}

while((ios = read_atomic(s_etat_processus,	while((ios = (int) read_atomic_signal(s_etat_processus,
pipes_sortie[0], &(tampon[pointeur]),	pipes_sortie[0], &(tampon[pointeur]),
longueur_lecture)) > 0)	(size_t) longueur_lecture)) >= 0)
{	{
while(sem_wait(&((*s_etat_processus).semaphore_fork))	# ifndef SEMAPHORES_NOMMES
!= 0)	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	while(sem_wait((*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;
}	}

	longueur_lue += ios;
tampon[pointeur + ios] = d_code_fin_chaine;	tampon[pointeur + ios] = d_code_fin_chaine;
pointeur += longueur_lecture;	pointeur += ios;
nombre_iterations++;

if ((tampon = realloc(tampon,	if ((tampon = realloc(tampon,
((nombre_iterations * longueur_lecture) + 1) *	((size_t) ((longueur_lue + longueur_lecture) + 1))
sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return;	return;
}	}

if (sem_post(&((*s_etat_processus).semaphore_fork))	# ifndef SEMAPHORES_NOMMES
!= 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;
}	}

	if ((*s_etat_processus).var_volatile_requete_arret == -1)
	{
	gettimeofday(&horodatage_initial, NULL);

	if ((*s_etat_processus).var_volatile_alarme == -1)
	{
	kill(pid, SIGKILL);
	}
	else
	{
	kill(pid, SIGTERM);
	}

	if ((fpipe = fdopen(pipes_sortie[0], "r")) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	return;
	}

	etape = 1;
	registre_ios = ios;

	while((ios = getc(fpipe)) != EOF)
	{
	if (etape == 1)
	{
	gettimeofday(&horodatage_final, NULL);

	// Si au bout de 10 secondes après le premier
	// signal, il reste des données à lire, le processus
	// est sans doute encore actif. On envoie donc
	// un signal 9.

	if ((horodatage_final.tv_sec -
	horodatage_initial.tv_sec) > 10)
	{
	etape = 2;
	kill(pid, SIGKILL);
	gettimeofday(&horodatage_initial, NULL);
	}
	}
	}

	ios = registre_ios;
	break;
	}
}	}

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

if ((tampon = realloc(tampon, (strlen(tampon) + 1) *	if (presence_stdin == d_vrai)
sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	if (pthread_join(thread_stdin_tid, NULL) != 0)
d_es_allocation_memoire;	{
return;	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}

	if (arguments_stdin.erreur != d_es)
	{
	(*s_etat_processus).erreur_systeme = arguments_stdin.erreur;
	return;
	}
}	}
	else
	{
	if (close(pipes_entree[1]) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	}

	do
	{
	if (kill(pid, 0) != 0)
	{
	// Le processus n'existe plus.
	break;
	}

	/*
	* Récupération de la valeur de retour du processus détaché
	*/

	# ifndef SEMAPHORES_NOMMES
	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;
	return;
	}

	while(waitpid(pid, &status, 0) == -1)
	{
	if (errno != EINTR)
	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
	}

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

if (ios == -1)	if (ios == -1)
{	{
Line 4047 instruction_syseval(struct_processus *s_	Line 4229 instruction_syseval(struct_processus *s_
* Transformation de la chaîne en liste	* Transformation de la chaîne en liste
*/	*/

longueur_tampon = strlen(tampon);	longueur_tampon = (integer8) strlen(tampon);

for(i = 0, ptr = tampon, nombre_lignes = 0;	for(i = 0, ptr = tampon, nombre_lignes = 0;
i < (long) longueur_tampon; i++, ptr++)	i < longueur_tampon; i++, ptr++)
{	{
if ((*ptr) == d_code_retour_chariot)	if ((*ptr) == d_code_retour_chariot)
{	{
Line 4084 instruction_syseval(struct_processus *s_	Line 4266 instruction_syseval(struct_processus *s_
l_element_courant = (struct_liste_chainee *)	l_element_courant = (struct_liste_chainee *)
(*s_objet_resultat).objet;	(*s_objet_resultat).objet;

for(i = 0, ptr = tampon; i < (long) nombre_lignes; i++)	for(i = 0, ptr = tampon; i < nombre_lignes; i++)
{	{
if (((*l_element_courant).donnee =	if (((*l_element_courant).donnee =
allocation(s_etat_processus, CHN)) == NULL)	allocation(s_etat_processus, CHN)) == NULL)
Line 4095 instruction_syseval(struct_processus *s_	Line 4277 instruction_syseval(struct_processus *s_
}	}

if ((((l_element_courant).donnee).objet =	if ((((l_element_courant).donnee).objet =
malloc((strlen(ptr) + 1) * sizeof(unsigned char)))	analyse_flux(s_etat_processus, ptr,
== NULL)	(integer8) strlen(ptr))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return;	return;
}	}

strcpy(((l_element_courant).donnee).objet, ptr);

while((*ptr) != d_code_fin_chaine)	while((*ptr) != d_code_fin_chaine)
{	{
ptr++;	ptr++;
Line 4135 instruction_syseval(struct_processus *s_	Line 4315 instruction_syseval(struct_processus *s_
free(tampon);	free(tampon);
}	}

if (sigaction(SIGINT, &action_passee, NULL) != 0)
{
for(i = 0; i < nombre_arguments; i++)
{
depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
&s_objet_temporaire);
liberation(s_etat_processus, s_objet_temporaire);
}

free(arguments);
(*s_etat_processus).erreur_systeme = d_es_signal;
return;
}

for(i = 0; i < nombre_arguments; i++)	for(i = 0; i < nombre_arguments; i++)
{	{
depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
Line 4156 instruction_syseval(struct_processus *s_	Line 4322 instruction_syseval(struct_processus *s_
liberation(s_etat_processus, s_objet_temporaire);	liberation(s_etat_processus, s_objet_temporaire);
}	}

	free(arguments);

if ((tampon = malloc(sizeof(unsigned char))) == NULL)	if ((tampon = malloc(sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return;	return;
}	}

if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	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;
Line 4179 instruction_syseval(struct_processus *s_	Line 4351 instruction_syseval(struct_processus *s_
&((*s_etat_processus).l_base_pile), s_objet_resultat)	&((*s_etat_processus).l_base_pile), s_objet_resultat)
== d_erreur)	== d_erreur)
{	{
if (sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)	# ifndef SEMAPHORES_NOMMES
	while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
	# else
	while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
	# endif
{	{
(*s_etat_processus).erreur_systeme = d_es_processus;	if (errno != EINTR)
return;	{
	(*s_etat_processus).erreur_systeme = d_es_processus;
	return;
	}
}	}

if (close(pipes_erreur[0]) != 0)	if (close(pipes_erreur[0]) != 0)
Line 4195 instruction_syseval(struct_processus *s_	Line 4374 instruction_syseval(struct_processus *s_
return;	return;
}	}

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

if (close(pipes_erreur[0]) != 0)	if (close(pipes_erreur[0]) != 0)
Line 4207 instruction_syseval(struct_processus *s_	Line 4393 instruction_syseval(struct_processus *s_
return;	return;
}	}

free(arguments);
free(tampon);	free(tampon);
}	}
else	else
Line 4804 instruction_sci(struct_processus *s_etat	Line 4989 instruction_sci(struct_processus *s_etat
return;	return;
}	}

(((logical8 ) (*s_objet).objet)) =	(((logical8 ) (*s_objet).objet)) = (logical8)
(((integer8 ) (*s_objet_argument).objet));	(((integer8 ) (*s_objet_argument).objet));

i43 = test_cfsf(s_etat_processus, 43);	i43 = test_cfsf(s_etat_processus, 43);
Line 4842 instruction_sci(struct_processus *s_etat	Line 5027 instruction_sci(struct_processus *s_etat
{	{
if (valeur_binaire[i] == '0')	if (valeur_binaire[i] == '0')
{	{
cf(s_etat_processus, j++);	cf(s_etat_processus, (unsigned char) j++);
}	}
else	else
{	{
sf(s_etat_processus, j++);	sf(s_etat_processus, (unsigned char) j++);
}	}
}	}

for(; j <= 56; cf(s_etat_processus, j++));	for(; j <= 56; cf(s_etat_processus, (unsigned char) j++));

cf(s_etat_processus, 49);	cf(s_etat_processus, 49);
sf(s_etat_processus, 50);	sf(s_etat_processus, 50);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.39
changed lines
	Added in v.1.110