rpl/src/instructions_r4.c - diff

Return to instructions_r4.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_r4.c between versions 1.1.1.1 and 1.6

version 1.1.1.1, 2010/01/26 15:22:45	version 1.6, 2010/03/07 17:03:29
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.9	RPL/2 (R) version 4.0.12
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2010 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
Line 751 instruction_relax(struct_processus *s_et	Line 751 instruction_relax(struct_processus *s_et
void	void
instruction_rewind(struct_processus *s_etat_processus)	instruction_rewind(struct_processus *s_etat_processus)
{	{
file *descripteur;	struct_descripteur_fichier *descripteur;

struct_objet *s_objet_argument;	struct_objet *s_objet_argument;

Line 803 instruction_rewind(struct_processus *s_e	Line 803 instruction_rewind(struct_processus *s_e
return;	return;
}	}

if (fseek(descripteur, (long) 0, SEEK_SET) != 0)	if ((*descripteur).type == 'C')
	{
	if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_SET) != 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
	return;
	}
	}
	else
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument);

(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;
return;	return;
}	}
}	}
Line 838 instruction_rewind(struct_processus *s_e	Line 846 instruction_rewind(struct_processus *s_e
void	void
instruction_read(struct_processus *s_etat_processus)	instruction_read(struct_processus *s_etat_processus)
{	{
file *descripteur;	const char *queue;

logical1 indicateur_48;	logical1 indicateur_48;
logical1 presence_chaine;	logical1 presence_chaine;
Line 854 instruction_read(struct_processus *s_eta	Line 862 instruction_read(struct_processus *s_eta

socklen_t longueur_adresse;	socklen_t longueur_adresse;

	sqlite3_stmt *ppStmt;

struct flock lock;	struct flock lock;

struct sockaddr_un adresse_unix;	struct sockaddr_un adresse_unix;
Line 862 instruction_read(struct_processus *s_eta	Line 872 instruction_read(struct_processus *s_eta

struct timespec attente;	struct timespec attente;

	struct_descripteur_fichier *descripteur;

struct_objet *s_objet_adresse;	struct_objet *s_objet_adresse;
struct_objet *s_objet_argument;	struct_objet *s_objet_argument_1;
	struct_objet *s_objet_argument_2;
struct_objet *s_objet_resultat;	struct_objet *s_objet_resultat;
struct_objet *s_objet_type;	struct_objet *s_objet_type;

unsigned char caractere;	unsigned char caractere;
	unsigned char *commande;
unsigned char *tampon_lecture;	unsigned char *tampon_lecture;
unsigned char *tampon;	unsigned char *tampon;

Line 891 instruction_read(struct_processus *s_eta	Line 905 instruction_read(struct_processus *s_eta
printf("(read a record of a file)\n\n");	printf("(read a record of a file)\n\n");
}	}

printf(" 1: %s, %s\n", d_FCH, d_SCK);	printf(" 1: %s, %s\n\n", d_FCH, d_SCK);
printf(" To be fixed !\n");

	printf(" 1: %s, %s\n", d_INT, d_CHN);
	printf(" 1: %s\n", d_FCH);
return;	return;
}	}
else if ((*s_etat_processus).test_instruction == 'Y')	else if ((*s_etat_processus).test_instruction == 'Y')
Line 904 instruction_read(struct_processus *s_eta	Line 919 instruction_read(struct_processus *s_eta

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

	if ((((*s_etat_processus).l_base_pile).donnee).type == FCH)
	{
	if ((((struct_fichier ) (((*s_etat_processus).l_base_pile)
	.donnee).objet)).acces == 'S')
	{
	if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
	{
	return;
	}
	}
	else
	{
	if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
	{
	return;
	}
	}
	}
	else
	{
	if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
	{
	return;
	}
	}
}	}

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

if ((*s_objet_argument).type == FCH)	if ((*s_objet_argument_1).type == FCH)
{	{
	if ((descripteur = descripteur_fichier(s_etat_processus,
	(struct_fichier ) (s_objet_argument_1).objet)) == NULL)
	{
	return;
	}

/*	/*
* Vérification des verrous	* Vérification des verrous
*/	*/
Line 929 instruction_read(struct_processus *s_eta	Line 977 instruction_read(struct_processus *s_eta
lock.l_len = 0;	lock.l_len = 0;
lock.l_pid = getpid();	lock.l_pid = getpid();

if ((descripteur = descripteur_fichier(s_etat_processus,	if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
(struct_fichier ) (s_objet_argument).objet)) == NULL)	== -1)
{
return;
}

if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);

(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
return;	return;
Line 945 instruction_read(struct_processus *s_eta	Line 988 instruction_read(struct_processus *s_eta

if (lock.l_type != F_UNLCK)	if (lock.l_type != F_UNLCK)
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_fichier_verrouille;	d_ex_fichier_verrouille;
Line 956 instruction_read(struct_processus *s_eta	Line 999 instruction_read(struct_processus *s_eta
* Vérification de l'autorisation de lecture	* Vérification de l'autorisation de lecture
*/	*/

if ((((struct_fichier ) (*s_objet_argument).objet)).protection == 'W')	if ((((struct_fichier ) (*s_objet_argument_1).objet)).protection
	== 'W')
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);

(*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;	(*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
return;	return;
}	}
else if ((((struct_fichier ) (*s_objet_argument).objet)).protection	else if ((((struct_fichier ) (*s_objet_argument_1).objet)).protection
== 'N')	== 'N')
{	{
if (fflush(descripteur) != 0)	if ((*descripteur).type == 'C')
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	if (fflush((*descripteur).descripteur_c) != 0)
return;	{
	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
	return;
	}
}	}
}	}

if ((((struct_fichier ) (*s_objet_argument).objet)).binaire == 'N')	if ((((struct_fichier ) (*s_objet_argument_1).objet)).binaire == 'N')
{	{
/*	/*
* Fichiers formatés	* Fichiers formatés
*/	*/

if ((((struct_fichier ) (*s_objet_argument).objet)).acces == 'S')	if ((((struct_fichier ) (*s_objet_argument_1).objet)).acces
	== 'S')
{	{
/*	/*
* Fichiers séquentiels	* Fichiers séquentiels
Line 995 instruction_read(struct_processus *s_eta	Line 1043 instruction_read(struct_processus *s_eta
return;	return;
}	}

if ((position_initiale = ftell(descripteur)) == -1)	BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));

	if ((position_initiale = ftell((*descripteur).descripteur_c))
	== -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
return;	return;
Line 1005 instruction_read(struct_processus *s_eta	Line 1056 instruction_read(struct_processus *s_eta
{	{
longueur_effective = fread(tampon_lecture,	longueur_effective = fread(tampon_lecture,
(size_t) sizeof(unsigned char), longueur_questure,	(size_t) sizeof(unsigned char), longueur_questure,
descripteur);	(*descripteur).descripteur_c);

pointeur = 0;	pointeur = 0;
presence_indicateur = d_faux;	presence_indicateur = d_faux;
Line 1030 instruction_read(struct_processus *s_eta	Line 1081 instruction_read(struct_processus *s_eta

if (presence_indicateur == d_faux)	if (presence_indicateur == d_faux)
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);
free(tampon_lecture);	free(tampon_lecture);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
Line 1042 instruction_read(struct_processus *s_eta	Line 1093 instruction_read(struct_processus *s_eta
presence_chaine = d_faux;	presence_chaine = d_faux;
niveau = 1;	niveau = 1;

if (fseek(descripteur, position_finale, SEEK_SET) != 0)	if (fseek((*descripteur).descripteur_c, position_finale,
	SEEK_SET) != 0)
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);
free(tampon_lecture);	free(tampon_lecture);

(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1055 instruction_read(struct_processus *s_eta	Line 1107 instruction_read(struct_processus *s_eta
{	{
longueur_effective = fread(tampon_lecture,	longueur_effective = fread(tampon_lecture,
(size_t) sizeof(unsigned char), longueur_questure,	(size_t) sizeof(unsigned char), longueur_questure,
descripteur);	(*descripteur).descripteur_c);

pointeur = 0;	pointeur = 0;
presence_indicateur = d_faux;	presence_indicateur = d_faux;
Line 1100 instruction_read(struct_processus *s_eta	Line 1152 instruction_read(struct_processus *s_eta

if (presence_indicateur == d_faux)	if (presence_indicateur == d_faux)
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);
free(tampon_lecture);	free(tampon_lecture);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
Line 1119 instruction_read(struct_processus *s_eta	Line 1171 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (fseek(descripteur, position_initiale, SEEK_SET) != 0)	if (fseek((*descripteur).descripteur_c, position_initiale,
	SEEK_SET) != 0)
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);
free(tampon_lecture);	free(tampon_lecture);

(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1131 instruction_read(struct_processus *s_eta	Line 1184 instruction_read(struct_processus *s_eta
longueur_effective = fread(tampon_lecture,	longueur_effective = fread(tampon_lecture,
(size_t) sizeof(unsigned char),	(size_t) sizeof(unsigned char),
(size_t) longueur_enregistrement,	(size_t) longueur_enregistrement,
descripteur);	(*descripteur).descripteur_c);

if (longueur_effective != longueur_enregistrement)	if (longueur_effective != longueur_enregistrement)
{	{
Line 1141 instruction_read(struct_processus *s_eta	Line 1194 instruction_read(struct_processus *s_eta

tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;	tampon_lecture[longueur_enregistrement] = d_code_fin_chaine;
tampon = (*s_etat_processus).instruction_courante;	tampon = (*s_etat_processus).instruction_courante;
(*s_etat_processus).instruction_courante = tampon_lecture;
	if (((*s_etat_processus).instruction_courante =
	transliteration(s_etat_processus, tampon_lecture,
	"UTF-8", d_locale)) == NULL)
	{
	(*s_etat_processus).instruction_courante = tampon;
	liberation(s_etat_processus, s_objet_argument_1);
	free(tampon_lecture);
	return;
	}

indicateur_48 = test_cfsf(s_etat_processus, 48);	indicateur_48 = test_cfsf(s_etat_processus, 48);
cf(s_etat_processus, 48);	cf(s_etat_processus, 48);

recherche_type(s_etat_processus);	recherche_type(s_etat_processus);
	free((*s_etat_processus).instruction_courante);

if ((*s_etat_processus).erreur_execution != d_ex)	if ((*s_etat_processus).erreur_execution != d_ex)
{	{
	if (indicateur_48 == d_vrai)
	{
	sf(s_etat_processus, 48);
	}
	else
	{
	cf(s_etat_processus, 48);
	}

(*s_etat_processus).instruction_courante = tampon;	(*s_etat_processus).instruction_courante = tampon;
free(tampon_lecture);	free(tampon_lecture);

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

return;	return;
}	}

Line 1170 instruction_read(struct_processus *s_eta	Line 1241 instruction_read(struct_processus *s_eta
(*s_etat_processus).instruction_courante = tampon;	(*s_etat_processus).instruction_courante = tampon;
free(tampon_lecture);	free(tampon_lecture);
}	}
else if ((((struct_fichier ) (*s_objet_argument).objet)).acces	else if ((((struct_fichier ) (*s_objet_argument_1).objet)).acces
== 'D')	== 'D')
{	{
	BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));

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

	if ((*s_objet_argument_2).type != INT)
	{
	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);

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

	if (alsprintf(&commande, "select data from data where "
	"id = %lld", (((integer8 ) (*s_objet_argument_2)
	.objet))) < 0)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return;
	}

	if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
	commande, strlen(commande), &ppStmt, &queue)
	!= SQLITE_OK)
	{
	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
	return;
	}


	switch(sqlite3_step(ppStmt))
	{
	case SQLITE_ROW:
	{
	// Résultat attendu
	break;
	}

	case SQLITE_DONE:
	{
	// Aucun enregistrement
	if (sqlite3_finalize(ppStmt) != SQLITE_OK)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	return;
	}

	free(commande);

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

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

	default:
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	return;
	}
	}

	if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
	{
	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
	return;
	}

	tampon = (*s_etat_processus).instruction_courante;

	if ((tampon_lecture = (unsigned char *)
	sqlite3_column_text(ppStmt, 0)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
	return;
	}

	if (((*s_etat_processus).instruction_courante =
	transliteration(s_etat_processus, tampon_lecture,
	"UTF-8", d_locale)) == NULL)
	{
	(*s_etat_processus).instruction_courante = tampon;

	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_argument_2);
	free(commande);
	return;
	}

	indicateur_48 = test_cfsf(s_etat_processus, 48);
	cf(s_etat_processus, 48);

	recherche_type(s_etat_processus);

	if ((*s_etat_processus).erreur_execution != d_ex)
	{
	if (indicateur_48 == d_vrai)
	{
	sf(s_etat_processus, 48);
	}
	else
	{
	cf(s_etat_processus, 48);
	}

	(*s_etat_processus).instruction_courante = tampon;

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

	free((*s_etat_processus).instruction_courante);
	free(commande);
	return;
	}

	if (indicateur_48 == d_vrai)
	{
	sf(s_etat_processus, 48);
	}
	else
	{
	cf(s_etat_processus, 48);
	}

	free((*s_etat_processus).instruction_courante);
	liberation(s_etat_processus, s_objet_argument_2);
	(*s_etat_processus).instruction_courante = tampon;

	if (sqlite3_step(ppStmt) != SQLITE_DONE)
	{
	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
	return;
	}

	if (sqlite3_finalize(ppStmt) != SQLITE_OK)
	{
	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
	return;
	}

	free(commande);
}	}
else	else
{	{
}	}
}	}
else if ((((struct_fichier ) (*s_objet_argument).objet)).binaire	else if ((((struct_fichier ) (*s_objet_argument_1).objet)).binaire
== 'Y')	== 'Y')
{	{
/*	/*
Line 1192 instruction_read(struct_processus *s_eta	Line 1415 instruction_read(struct_processus *s_eta
*/	*/
}	}
}	}
else if ((*s_objet_argument).type == SCK)	else if ((*s_objet_argument_1).type == SCK)
{	{
/*	/*
* Vérification de l'autorisation de lecture	* Vérification de l'autorisation de lecture
*/	*/

if ((((struct_socket ) (*s_objet_argument).objet)).protection == 'W')	if ((((struct_socket ) (*s_objet_argument_1).objet)).protection
	== 'W')
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);

(*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;	(*s_etat_processus).erreur_execution = d_ex_erreur_acces_fichier;
return;	return;
Line 1210 instruction_read(struct_processus *s_eta	Line 1434 instruction_read(struct_processus *s_eta
* Vérification de l'écoute de la socket si celle-ci est connectée	* Vérification de l'écoute de la socket si celle-ci est connectée
*/	*/

if ((strcmp((((struct_socket ) (*s_objet_argument).objet)).type,	if ((strcmp((((struct_socket ) (*s_objet_argument_1).objet)).type,
"STREAM") == 0) \|\| (strcmp((((struct_socket )	"STREAM") == 0) \|\| (strcmp((((struct_socket )
(*s_objet_argument).objet)).type, "SEQUENTIAL DATAGRAM") == 0))	(*s_objet_argument_1).objet)).type, "SEQUENTIAL DATAGRAM")
	== 0))
{	{
if ((((struct_socket ) (*s_objet_argument).objet))	if ((((struct_socket ) (*s_objet_argument_1).objet))
.socket_en_ecoute == 'Y')	.socket_en_ecoute == 'Y')
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);

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

if ((((struct_socket ) (*s_objet_argument).objet)).binaire == 'N')	if ((((struct_socket ) (*s_objet_argument_1).objet)).binaire == 'N')
{ // Socket formatée	{ // Socket formatée
longueur_questure = 256;	longueur_questure = 256;

Line 1246 instruction_read(struct_processus *s_eta	Line 1471 instruction_read(struct_processus *s_eta

for(;;)	for(;;)
{	{
if ((((struct_socket ) (*s_objet_argument).objet)).domaine	if ((((struct_socket ) (*s_objet_argument_1).objet))
== PF_UNIX)	.domaine == PF_UNIX)
{	{
longueur_adresse = sizeof(adresse_unix);	longueur_adresse = sizeof(adresse_unix);
longueur_effective = recvfrom((((struct_socket )	longueur_effective = recvfrom((((struct_socket )
(*s_objet_argument).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_questure,	tampon_lecture, longueur_questure,
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_unix, &longueur_adresse);	&adresse_unix, &longueur_adresse);
}	}
else if ((((struct_socket ) (*s_objet_argument).objet))	else if ((((struct_socket ) (*s_objet_argument_1).objet))
.domaine == PF_INET)	.domaine == PF_INET)
{	{
longueur_adresse = sizeof(adresse_ipv4);	longueur_adresse = sizeof(adresse_ipv4);
longueur_effective = recvfrom((((struct_socket )	longueur_effective = recvfrom((((struct_socket )
(*s_objet_argument).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_questure,	tampon_lecture, longueur_questure,
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv4, &longueur_adresse);	&adresse_ipv4, &longueur_adresse);
}	}
else if ((((struct_socket ) (*s_objet_argument).objet))	else if ((((struct_socket ) (*s_objet_argument_1).objet))
.domaine == PF_INET6)	.domaine == PF_INET6)
{	{
longueur_adresse = sizeof(adresse_ipv6);	longueur_adresse = sizeof(adresse_ipv6);
longueur_effective = recvfrom((((struct_socket )	longueur_effective = recvfrom((((struct_socket )
(*s_objet_argument).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_questure,	tampon_lecture, longueur_questure,
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv6, &longueur_adresse);	&adresse_ipv6, &longueur_adresse);
Line 1279 instruction_read(struct_processus *s_eta	Line 1504 instruction_read(struct_processus *s_eta
else	else
{	{
free(tampon_lecture);	free(tampon_lecture);
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);

while(sem_wait(&((*s_etat_processus)	while(sem_wait(&((*s_etat_processus)
.semaphore_fork)) == -1)	.semaphore_fork)) == -1)
Line 1331 instruction_read(struct_processus *s_eta	Line 1556 instruction_read(struct_processus *s_eta
*/	*/

free(tampon_lecture);	free(tampon_lecture);
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);
return;	return;
}	}

if (longueur_effective == -1)	if (longueur_effective == -1)
{	{
free(tampon_lecture);	free(tampon_lecture);
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_erreur_acces_fichier;	d_ex_erreur_acces_fichier;
Line 1405 instruction_read(struct_processus *s_eta	Line 1630 instruction_read(struct_processus *s_eta
{	{
if (longueur_effective < longueur_questure)	if (longueur_effective < longueur_questure)
{	{
liberation(s_etat_processus, s_objet_argument);	liberation(s_etat_processus, s_objet_argument_1);
free(tampon_lecture);	free(tampon_lecture);

(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
Line 1433 instruction_read(struct_processus *s_eta	Line 1658 instruction_read(struct_processus *s_eta
(*s_etat_processus).instruction_courante = tampon;	(*s_etat_processus).instruction_courante = tampon;
free(tampon_lecture);	free(tampon_lecture);

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

return;	return;
}	}

Line 1503 instruction_read(struct_processus *s_eta	Line 1727 instruction_read(struct_processus *s_eta
* Dans tous les autres cas, on renvoie une liste vide.	* Dans tous les autres cas, on renvoie une liste vide.
*/	*/

if (((((struct_socket ) (*s_objet_argument).objet)).domaine	if (((((struct_socket ) (*s_objet_argument_1).objet)).domaine
== PF_UNIX) \|\| (strcmp((((struct_socket )	== PF_UNIX) \|\| (strcmp((((struct_socket )
(*s_objet_argument).objet)).type, "STREAM") == 0) \|\|	(*s_objet_argument_1).objet)).type, "STREAM") == 0) \|\|
(strcmp((((struct_socket ) (*s_objet_argument).objet))	(strcmp((((struct_socket ) (*s_objet_argument_1).objet))
.type, "SEQUENTIAL DATAGRAM") == 0))	.type, "SEQUENTIAL DATAGRAM") == 0))
{	{
longueur_adresse = 0;	longueur_adresse = 0;
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument).objet)).socket, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	position_finale, MSG_DONTWAIT,
NULL, &longueur_adresse);	NULL, &longueur_adresse);

(*s_objet_adresse).objet = NULL;	(*s_objet_adresse).objet = NULL;
}	}
else if ((((struct_socket ) (*s_objet_argument).objet))	else if ((((struct_socket ) (*s_objet_argument_1).objet))
.domaine == PF_INET)	.domaine == PF_INET)
{	{
longueur_adresse = sizeof(adresse_ipv4);	longueur_adresse = sizeof(adresse_ipv4);
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument).objet)).socket, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	position_finale, MSG_DONTWAIT,
(struct sockaddr *) &adresse_ipv4, &longueur_adresse);	(struct sockaddr *) &adresse_ipv4, &longueur_adresse);

Line 1590 instruction_read(struct_processus *s_eta	Line 1814 instruction_read(struct_processus *s_eta
}	}

(((integer8 ) (((((struct_liste_chainee )	(((integer8 ) (((((struct_liste_chainee )
(*s_objet_adresse) .objet)).suivant).donnee).objet)) =	(*s_objet_adresse).objet)).suivant).donnee).objet)) =
(integer8) ntohs(adresse_ipv4.sin_port);	(integer8) ntohs(adresse_ipv4.sin_port);

((((struct_liste_chainee ) (s_objet_adresse).objet))	((((struct_liste_chainee ) (s_objet_adresse).objet))
.suivant).suivant = NULL;	.suivant).suivant = NULL;
}	}
else if ((((struct_socket ) (*s_objet_argument).objet))	else if ((((struct_socket ) (*s_objet_argument_1).objet))
.domaine == PF_INET6)	.domaine == PF_INET6)
{	{
longueur_adresse = sizeof(adresse_ipv6);	longueur_adresse = sizeof(adresse_ipv6);
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument).objet)).socket, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	position_finale, MSG_DONTWAIT,
(struct sockaddr *) &adresse_ipv6, &longueur_adresse);	(struct sockaddr *) &adresse_ipv6, &longueur_adresse);

Line 1660 instruction_read(struct_processus *s_eta	Line 1884 instruction_read(struct_processus *s_eta
}	}

(((integer8 ) (((((struct_liste_chainee )	(((integer8 ) (((((struct_liste_chainee )
(*s_objet_adresse) .objet)).suivant).donnee).objet)) =	(*s_objet_adresse).objet)).suivant).donnee).objet)) =
(integer8) ntohs(adresse_ipv6.sin6_port);	(integer8) ntohs(adresse_ipv6.sin6_port);

((((struct_liste_chainee ) (s_objet_adresse).objet))	((((struct_liste_chainee ) (s_objet_adresse).objet))
Line 1670 instruction_read(struct_processus *s_eta	Line 1894 instruction_read(struct_processus *s_eta
{	{
longueur_adresse = 0;	longueur_adresse = 0;
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument).objet)).socket, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	position_finale, MSG_DONTWAIT,
NULL, &longueur_adresse);	NULL, &longueur_adresse);
}	}
Line 1694 instruction_read(struct_processus *s_eta	Line 1918 instruction_read(struct_processus *s_eta
return;	return;
}	}

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

return;	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.1.1.1
changed lines
	Added in v.1.6