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.73 and 1.88

version 1.73, 2013/03/11 15:41:05	version 1.88, 2014/04/25 07:37:33
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.18
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2014 Dr. BERTRAND Joël

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

Line 96 instruction_r_vers_b(struct_processus *s	Line 96 instruction_r_vers_b(struct_processus *s
}	}
else	else
{	{
(((logical8 ) (s_objet_resultat).objet)) = (((integer8 *)	(((logical8 ) (*s_objet_resultat).objet)) = (logical8)
(*s_objet_argument).objet));	(((integer8 ) (*s_objet_argument).objet));
}	}
}	}
else	else
Line 850 instruction_read(struct_processus *s_eta	Line 850 instruction_read(struct_processus *s_eta

int c;	int c;
int ios;	int ios;
	int timeout;

integer8 element;	integer8 element;
integer8 i;	integer8 i;
integer8 id;	integer8 id;
	integer8 index;
	integer8 longueur;
integer8 position_clef;	integer8 position_clef;

integer8 longueur_effective;	integer8 longueur_effective;
integer8 longueur_enregistrement;	integer8 longueur_enregistrement;
integer8 longueur_questure;	integer8 longueur_questure;
Line 863 instruction_read(struct_processus *s_eta	Line 867 instruction_read(struct_processus *s_eta
integer8 position_finale;	integer8 position_finale;
integer8 position_initiale;	integer8 position_initiale;

	logical1 device;
logical1 format_degenere;	logical1 format_degenere;
logical1 indicateur_48;	logical1 indicateur_48;
logical1 presence_chaine;	logical1 presence_chaine;
logical1 presence_indicateur;	logical1 presence_indicateur;
logical1 trame_complete;	logical1 trame_complete;

long longueur;

socklen_t longueur_adresse;	socklen_t longueur_adresse;

sqlite3_stmt *ppStmt;	sqlite3_stmt *ppStmt;

struct flock lock;	struct flock lock;

	struct pollfd fds[1];

struct sockaddr_un adresse_unix;	struct sockaddr_un adresse_unix;
struct sockaddr_in adresse_ipv4;	struct sockaddr_in adresse_ipv4;
# ifdef IPV6	# ifdef IPV6
struct sockaddr_in6 adresse_ipv6;	struct sockaddr_in6 adresse_ipv6;
# endif	# endif

struct pollfd poll_fd;	struct termios tc;

struct timespec attente;	struct timespec attente;

Line 907 instruction_read(struct_processus *s_eta	Line 912 instruction_read(struct_processus *s_eta
unsigned char *tampon_lecture;	unsigned char *tampon_lecture;
unsigned char *tampon;	unsigned char *tampon;
unsigned char *tampon2;	unsigned char *tampon2;
	unsigned char *tampon3;

	int vitesses[] =
	{
	50, 75, 110, 134, 150, 200, 300, 600,
	1200, 1800, 2400, 4800, 9600, 19200, 38400,
	#ifdef B57600
	57600,
	#endif
	#ifdef B115200
	115200,
	#endif
	#ifdef B230400
	230400,
	#endif
	0
	};

	tcflag_t vitesses_constantes[] =
	{
	B50, B75, B110, B134, B150, B200, B300, B600,
	B1200, B1800, B2400, B4800, B9600, B19200, B38400,
	#ifdef B57600
	B57600,
	#endif
	#ifdef B115200
	B115200,
	#endif
	#ifdef B230400
	B230400,
	#endif
	0
	};

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

Line 1051 instruction_read(struct_processus *s_eta	Line 1089 instruction_read(struct_processus *s_eta
* Fichiers séquentiels	* Fichiers séquentiels
*/	*/

longueur_questure = 256;	longueur_questure = 4096;

if ((tampon_lecture = malloc(longueur_questure *	if ((tampon_lecture = malloc(((size_t) longueur_questure) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 1072 instruction_read(struct_processus *s_eta	Line 1110 instruction_read(struct_processus *s_eta

do	do
{	{
longueur_effective = fread(tampon_lecture,	longueur_effective = (integer8) fread(tampon_lecture,
(size_t) sizeof(unsigned char), longueur_questure,	sizeof(unsigned char), (size_t) longueur_questure,
(*descripteur).descripteur_c);	(*descripteur).descripteur_c);

pointeur = 0;	pointeur = 0;
Line 1111 instruction_read(struct_processus *s_eta	Line 1149 instruction_read(struct_processus *s_eta
presence_chaine = d_faux;	presence_chaine = d_faux;
niveau = 1;	niveau = 1;

if (fseek((*descripteur).descripteur_c, position_finale,	if (fseek((*descripteur).descripteur_c, (long) position_finale,
SEEK_SET) != 0)	SEEK_SET) != 0)
{	{
liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
Line 1123 instruction_read(struct_processus *s_eta	Line 1161 instruction_read(struct_processus *s_eta

do	do
{	{
longueur_effective = fread(tampon_lecture,	longueur_effective = (integer8) fread(tampon_lecture,
(size_t) sizeof(unsigned char), longueur_questure,	sizeof(unsigned char), (size_t) longueur_questure,
(*descripteur).descripteur_c);	(*descripteur).descripteur_c);

pointeur = 0;	pointeur = 0;
Line 1192 instruction_read(struct_processus *s_eta	Line 1230 instruction_read(struct_processus *s_eta
free(tampon_lecture);	free(tampon_lecture);
longueur_enregistrement = position_finale - position_initiale;	longueur_enregistrement = position_finale - position_initiale;

if ((tampon_lecture = malloc((longueur_enregistrement + 1) *	if ((tampon_lecture = malloc(((size_t)
	(longueur_enregistrement + 1)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 1200 instruction_read(struct_processus *s_eta	Line 1239 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (fseek((*descripteur).descripteur_c, position_initiale,	if (fseek((*descripteur).descripteur_c,
SEEK_SET) != 0)	(long) position_initiale, SEEK_SET) != 0)
{	{
liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
free(tampon_lecture);	free(tampon_lecture);
Line 1210 instruction_read(struct_processus *s_eta	Line 1249 instruction_read(struct_processus *s_eta
return;	return;
}	}

longueur_effective = fread(tampon_lecture,	longueur_effective = (integer8) fread(tampon_lecture,
(size_t) sizeof(unsigned char),	sizeof(unsigned char), (size_t) longueur_enregistrement,
(size_t) longueur_enregistrement,
(*descripteur).descripteur_c);	(*descripteur).descripteur_c);

if (longueur_effective != longueur_enregistrement)	if (longueur_effective != longueur_enregistrement)
Line 1302 instruction_read(struct_processus *s_eta	Line 1340 instruction_read(struct_processus *s_eta
}	}

if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,	if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
commande, strlen(commande), &ppStmt, &queue)	commande, (int) strlen(commande), &ppStmt, &queue)
!= SQLITE_OK)	!= SQLITE_OK)
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1473 instruction_read(struct_processus *s_eta	Line 1511 instruction_read(struct_processus *s_eta
}	}

if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,	if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
commande, strlen(commande), &ppStmt, &queue)	commande, (int) strlen(commande), &ppStmt, &queue)
!= SQLITE_OK)	!= SQLITE_OK)
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1547 instruction_read(struct_processus *s_eta	Line 1585 instruction_read(struct_processus *s_eta
}	}

if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,	if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
commande, strlen(commande), &ppStmt, &queue)	commande, (int) strlen(commande), &ppStmt, &queue)
!= SQLITE_OK)	!= SQLITE_OK)
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1640 instruction_read(struct_processus *s_eta	Line 1678 instruction_read(struct_processus *s_eta
}	}

if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,	if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
commande, strlen(commande), &ppStmt, &queue)	commande, (int) strlen(commande), &ppStmt, &queue)
!= SQLITE_OK)	!= SQLITE_OK)
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
Line 1976 instruction_read(struct_processus *s_eta	Line 2014 instruction_read(struct_processus *s_eta
BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));	BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
longueur_enregistrement = 0;	longueur_enregistrement = 0;

	device = d_faux;

if ((position_initiale = ftell((*descripteur).descripteur_c))	if ((position_initiale = ftell((*descripteur).descripteur_c))
== -1)	== -1)
{	{
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;	if (errno == ESPIPE)
return;	{
	device = d_vrai;
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	return;
	}
}	}

l_element_courant_format = (struct_liste_chainee *)	l_element_courant_format = (struct_liste_chainee *)
Line 2028 instruction_read(struct_processus *s_eta	Line 2076 instruction_read(struct_processus *s_eta
return;	return;
}	}

longueur = strlen(format_chaine);	longueur = (integer8) strlen(format_chaine);

if (format_chaine[longueur - 1] != ')')	if (format_chaine[longueur - 1] != ')')
{	{
Line 2052 instruction_read(struct_processus *s_eta	Line 2100 instruction_read(struct_processus *s_eta
// Détermination de la longueur	// Détermination de la longueur
format_degenere = d_faux;	format_degenere = d_faux;

if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)	if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1)
{	{
liberation(s_etat_processus, s_objet_argument_1);	liberation(s_etat_processus, s_objet_argument_1);
liberation(s_etat_processus, s_objet_resultat);	liberation(s_etat_processus, s_objet_resultat);
Line 2065 instruction_read(struct_processus *s_eta	Line 2113 instruction_read(struct_processus *s_eta
}	}

free(format_chaine);	free(format_chaine);
	tampon3 = NULL;

if (format_degenere == d_vrai)	if (format_degenere == d_vrai)
{	{
	if (device == d_vrai)
	{
	longueur_questure = 4096;
	index = 0;

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

	tampon3[index] = d_code_fin_chaine;

	fds[0].fd = fileno((*descripteur).descripteur_c);
	fds[0].events = POLLIN;
	fds[0].revents = 0;

	tcgetattr(fileno((*descripteur).descripteur_c),
	&tc);
	timeout = 0;

	for(i = 0; vitesses[i] != 0; i++)
	{
	if (cfgetispeed(&tc) == vitesses_constantes[i])
	{
	// La durée entre deux caractères sur le
	// périphérique série ne doit pas dépasser
	// la moitié de la durée de transmission
	// d'un caractère complet.

	timeout = (int) (((double) 1000) /
	(((double) vitesses_constantes[i]) /
	4));
	break;
	}
	}
	}

do	do
{	{
	if (device == d_vrai)
	{
	if (poll(fds, 1, timeout) == 0)
	{
	break;
	}
	}

c = getc((*descripteur).descripteur_c);	c = getc((*descripteur).descripteur_c);
longueur_enregistrement++;	longueur_enregistrement++;
} while((c != '\n') && (c != EOF));

if (fseek((*descripteur).descripteur_c,	if (device == d_vrai)
position_initiale, SEEK_SET) != 0)	{
	if (longueur_enregistrement >=
	longueur_questure)
	{
	if ((tampon3 = realloc(tampon3,
	(size_t) (longueur_questure *= 2)))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return;
	}
	}

	tampon3[index++] = (unsigned char) c;
	}
	} while(c != EOF);

	if (device == d_faux)
{	{
liberation(s_etat_processus, s_objet_argument_1);	if (fseek((*descripteur).descripteur_c,
liberation(s_etat_processus, s_objet_resultat);	(long) position_initiale, SEEK_SET) != 0)
	{
	liberation(s_etat_processus,
	s_objet_argument_1);
	liberation(s_etat_processus, s_objet_resultat);

(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_erreur_fichier;	d_es_erreur_fichier;
return;	return;
	}
}	}
}	}
else	else
Line 2090 instruction_read(struct_processus *s_eta	Line 2209 instruction_read(struct_processus *s_eta
longueur_enregistrement = longueur;	longueur_enregistrement = longueur;
}	}

if ((tampon_lecture = malloc((longueur_enregistrement)	if ((device == d_vrai) && (format_degenere == d_vrai))
* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	longueur_effective = longueur_enregistrement;
d_es_allocation_memoire;	tampon_lecture = tampon3;
return;
}	}
	else
	{
	if ((tampon_lecture = malloc(((size_t)
	longueur_enregistrement) *
	sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return;
	}

longueur_effective = fread(tampon_lecture,	longueur_effective = (integer8) fread(tampon_lecture,
(size_t) sizeof(unsigned char),	sizeof(unsigned char),
(size_t) longueur_enregistrement,	(size_t) longueur_enregistrement,
(*descripteur).descripteur_c);	(*descripteur).descripteur_c);
	}

if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
Line 2141 instruction_read(struct_processus *s_eta	Line 2269 instruction_read(struct_processus *s_eta

if (format_degenere == d_vrai)	if (format_degenere == d_vrai)
{	{
if ((((l_element_courant).donnee).objet =	if (device == d_faux)
analyse_flux(s_etat_processus, tampon_lecture,
longueur_enregistrement - 1)) == NULL)
{	{
return;	if ((((l_element_courant).donnee).objet =
	analyse_flux(s_etat_processus, tampon_lecture,
	longueur_enregistrement - 1)) == NULL)
	{
	return;
	}
	}
	else
	{
	if ((((l_element_courant).donnee).objet =
	analyse_flux(s_etat_processus, tampon_lecture,
	longueur_enregistrement)) == NULL)
	{
	return;
	}
}	}
}	}
else	else
Line 2233 instruction_read(struct_processus *s_eta	Line 2373 instruction_read(struct_processus *s_eta
presence_indicateur = d_faux;	presence_indicateur = d_faux;

if ((tampon_lecture = realloc(tampon_lecture,	if ((tampon_lecture = realloc(tampon_lecture,
(longueur_effective + longueur_questure + 1)	((size_t) (longueur_effective + longueur_questure + 1))
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2258 instruction_read(struct_processus *s_eta	Line 2398 instruction_read(struct_processus *s_eta

do	do
{	{
ios = recvfrom((((struct_socket )	ios = (int) recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture,	tampon_lecture, (size_t) (longueur_effective +
longueur_effective + longueur_questure,	longueur_questure),
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_unix, &longueur_adresse);	&adresse_unix, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2273 instruction_read(struct_processus *s_eta	Line 2413 instruction_read(struct_processus *s_eta

do	do
{	{
ios = recvfrom((((struct_socket )	ios = (int) recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture,	tampon_lecture, (size_t) (longueur_effective +
longueur_effective + longueur_questure,	longueur_questure),
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv4, &longueur_adresse);	&adresse_ipv4, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2289 instruction_read(struct_processus *s_eta	Line 2429 instruction_read(struct_processus *s_eta

do	do
{	{
ios = recvfrom((((struct_socket )	ios = (int) recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture,	tampon_lecture, (size_t) (longueur_effective +
longueur_effective + longueur_questure,	longueur_questure),
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv6, &longueur_adresse);	&adresse_ipv6, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2335 instruction_read(struct_processus *s_eta	Line 2475 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (ios < 0)	if (ios <= 0)
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
scrutation_injection(s_etat_processus);
}	}
else	else
{	{
Line 2347 instruction_read(struct_processus *s_eta	Line 2486 instruction_read(struct_processus *s_eta
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;
}	}

	scrutation_injection(s_etat_processus);

if ((*s_etat_processus).var_volatile_requete_arret == -1)	if ((*s_etat_processus).var_volatile_requete_arret == -1)
{	{
if (ios >= 0)	if (ios >= 0)
{	{
longueur_effective += ios;	longueur_effective = ios;
}	}

break;	break;
Line 2361 instruction_read(struct_processus *s_eta	Line 2502 instruction_read(struct_processus *s_eta

if (ios >= 0)	if (ios >= 0)
{	{
longueur_effective += ios;	longueur_effective = ios;
position_initiale = 0;	position_initiale = 0;
presence_indicateur = d_faux;	presence_indicateur = d_faux;

Line 2443 instruction_read(struct_processus *s_eta	Line 2584 instruction_read(struct_processus *s_eta
longueur_adresse = sizeof(adresse_unix);	longueur_adresse = sizeof(adresse_unix);
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_effective,	tampon_lecture,
	(size_t) longueur_effective,
0, (struct sockaddr *)	0, (struct sockaddr *)
&adresse_unix, &longueur_adresse);	&adresse_unix, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2456 instruction_read(struct_processus *s_eta	Line 2598 instruction_read(struct_processus *s_eta
longueur_adresse = sizeof(adresse_ipv4);	longueur_adresse = sizeof(adresse_ipv4);
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_effective,	tampon_lecture,
	(size_t) longueur_effective,
0, (struct sockaddr *)	0, (struct sockaddr *)
&adresse_ipv4, &longueur_adresse);	&adresse_ipv4, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2470 instruction_read(struct_processus *s_eta	Line 2613 instruction_read(struct_processus *s_eta
longueur_adresse = sizeof(adresse_ipv6);	longueur_adresse = sizeof(adresse_ipv6);
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_effective,	tampon_lecture,
	(size_t) longueur_effective,
0, (struct sockaddr *)	0, (struct sockaddr *)
&adresse_ipv6, &longueur_adresse);	&adresse_ipv6, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2493 instruction_read(struct_processus *s_eta	Line 2637 instruction_read(struct_processus *s_eta
}	}
else	else
{	{
// Installation d'un timeout pour sortir de	// Si on a lu toute une trame et qu'on n'a pas
// l'instruction dans le cas où la transmission serait	// réussi à en trouver la structure, on remonte
// invalide et que la trame reçue serait erronée.	// une erreur de syntaxe.

poll_fd.fd = (((struct_socket )
(*s_objet_argument_1).objet)).socket;
poll_fd.events = POLLIN;

while((ios = poll(&poll_fd, 1, 10000)) <= 0)	if (longueur_effective == ios)
{	{
// La fin de la trame n'est pas atteinte.	if ((((struct_socket ) (*s_objet_argument_1)
	.objet)).domaine == PF_UNIX)
switch(ios)
{	{
case EINTR:	do
{	{
if ((*s_etat_processus)	longueur_adresse = sizeof(adresse_unix);
.var_volatile_requete_arret == -1)	recvfrom((((struct_socket )
{	(*s_objet_argument_1).objet))
liberation(s_etat_processus,	.socket, tampon_lecture,
s_objet_argument_1);	(size_t) longueur_effective,
free(tampon_lecture);	0, (struct sockaddr *)
return;	&adresse_unix, &longueur_adresse);
}	} while((ios == -1) && (errno == EINTR));
	}
break;	else if ((((struct_socket ) (*s_objet_argument_1)
	.objet)).domaine == PF_INET)
	{
	do
	{
	longueur_adresse = sizeof(adresse_ipv4);
	recvfrom((((struct_socket )
	(*s_objet_argument_1).objet))
	.socket, tampon_lecture,
	(size_t) longueur_effective,
	0, (struct sockaddr *)
	&adresse_ipv4, &longueur_adresse);
	} while((ios == -1) && (errno == EINTR));
	}
	else if ((((struct_socket ) (*s_objet_argument_1)
	.objet)) .domaine == PF_INET6)
	{
	# ifdef IPV6
	do
	{
	longueur_adresse = sizeof(adresse_ipv6);
	recvfrom((((struct_socket )
	(*s_objet_argument_1).objet))
	.socket, tampon_lecture,
	(size_t) longueur_effective,
	0, (struct sockaddr *)
	&adresse_ipv6, &longueur_adresse);
	} while((ios == -1) && (errno == EINTR));
	# else
	if ((*s_etat_processus).langue == 'F')
	{
	printf("+++Attention : Support du protocole"
	" IPv6 indisponible\n");
}	}
	else
case 0:
{	{
liberation(s_etat_processus,	printf("+++Warning : IPv6 support "
s_objet_argument_1);	"unavailable\n");
free(tampon_lecture);

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

	# endif
}	}

	liberation(s_etat_processus, s_objet_argument_1);
	free(tampon_lecture);

	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	return;
}	}
}	}
}	}
Line 2835 instruction_read(struct_processus *s_eta	Line 3008 instruction_read(struct_processus *s_eta
longueur_adresse = 0;	longueur_adresse = 0;
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	(size_t) position_finale, MSG_DONTWAIT,
NULL, &longueur_adresse);	NULL, &longueur_adresse);
}	}

Line 2866 instruction_read(struct_processus *s_eta	Line 3039 instruction_read(struct_processus *s_eta
presence_indicateur = d_faux;	presence_indicateur = d_faux;

if ((tampon_lecture = realloc(tampon_lecture,	if ((tampon_lecture = realloc(tampon_lecture,
(longueur_effective + longueur_questure + 1)	((size_t) (longueur_effective + longueur_questure) + 1)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 2891 instruction_read(struct_processus *s_eta	Line 3064 instruction_read(struct_processus *s_eta

do	do
{	{
ios = recvfrom((((struct_socket )	ios = (int) recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture,	tampon_lecture, (size_t)
longueur_effective + longueur_questure,	(longueur_effective + longueur_questure),
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_unix, &longueur_adresse);	&adresse_unix, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2906 instruction_read(struct_processus *s_eta	Line 3079 instruction_read(struct_processus *s_eta

do	do
{	{
ios = recvfrom((((struct_socket )	ios = (int) recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture,	tampon_lecture, (size_t)
longueur_effective + longueur_questure,	(longueur_effective + longueur_questure),
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv4, &longueur_adresse);	&adresse_ipv4, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2922 instruction_read(struct_processus *s_eta	Line 3095 instruction_read(struct_processus *s_eta

do	do
{	{
ios = recvfrom((((struct_socket )	ios = (int) recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture,	tampon_lecture, (size_t)
longueur_effective + longueur_questure,	(longueur_effective + longueur_questure),
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv6, &longueur_adresse);	&adresse_ipv6, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));	} while((ios == -1) && (errno == EINTR));
Line 2968 instruction_read(struct_processus *s_eta	Line 3141 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (ios < 0)	if (ios <= 0)
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
scrutation_injection(s_etat_processus);
}	}
else	else
{	{
Line 2980 instruction_read(struct_processus *s_eta	Line 3152 instruction_read(struct_processus *s_eta
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;
}	}

	scrutation_injection(s_etat_processus);

if ((*s_etat_processus).var_volatile_requete_arret == -1)	if ((*s_etat_processus).var_volatile_requete_arret == -1)
{	{
if (ios >= 0)	if (ios >= 0)
Line 2992 instruction_read(struct_processus *s_eta	Line 3166 instruction_read(struct_processus *s_eta

// Une donnée a été reçue.	// Une donnée a été reçue.

if (ios >= 0)	if (ios == (longueur_effective + longueur_questure))
{	{
longueur_effective += ios;	longueur_effective = ios;
position_initiale = 0;	position_initiale = 0;
presence_indicateur = d_faux;	presence_indicateur = d_faux;
	}
	else if (ios > 0)
	{
	// On retire une trame du buffer.

do	if ((((struct_socket ) (*s_objet_argument_1).objet))
	.domaine == PF_UNIX)
{	{
if (tampon_lecture[position_initiale] == '{')	do
{	{
presence_indicateur = d_vrai;	longueur_adresse = sizeof(adresse_unix);
break;	recvfrom((((struct_socket )
}	(*s_objet_argument_1).objet)).socket,
	tampon_lecture, (size_t) longueur_effective,
position_initiale++;	0, (struct sockaddr *)
} while(position_initiale < longueur_effective);	&adresse_unix, &longueur_adresse);
	} while((ios == -1) && (errno == EINTR));
if (presence_indicateur == d_vrai)	}
	else if ((((struct_socket ) (*s_objet_argument_1)
	.objet)).domaine == PF_INET)
{	{
position_finale = position_initiale + 1;	do
presence_chaine = d_faux;
presence_indicateur = d_faux;
niveau = 1;

while(position_finale < longueur_effective)
{	{
caractere = tampon_lecture[position_finale];	longueur_adresse = sizeof(adresse_ipv4);
	recvfrom((((struct_socket )
if (caractere == '"')	(*s_objet_argument_1).objet)).socket,
{	tampon_lecture, (size_t) longueur_effective,
if (position_finale > 0)	0, (struct sockaddr *)
{	&adresse_ipv4, &longueur_adresse);
if (tampon_lecture[position_finale - 1]	} while((ios == -1) && (errno == EINTR));
!= '\\')
{
presence_chaine = (presence_chaine ==
d_vrai) ? d_faux : d_vrai;
}
}
else
{
presence_chaine =
(presence_chaine == d_vrai)
? d_faux : d_vrai;
}
}
else
{
if (presence_chaine == d_faux)
{
if (caractere == '{')
{
niveau++;
}
else if (caractere == '}')
{
niveau--;
}
}
}

if (niveau == 0)
{
presence_indicateur = d_vrai;
trame_complete = d_vrai;
break;
}

position_finale++;
}
}	}
	else if ((((struct_socket ) (*s_objet_argument_1)
// On retire une trame du buffer.	.objet)) .domaine == PF_INET6)

if (trame_complete == d_vrai)
{	{
if ((((struct_socket ) (*s_objet_argument_1).objet))	# ifdef IPV6
.domaine == PF_UNIX)	do
{	{
do	longueur_adresse = sizeof(adresse_ipv6);
{	recvfrom((((struct_socket )
longueur_adresse = sizeof(adresse_unix);	(*s_objet_argument_1).objet)).socket,
recvfrom((((struct_socket )	tampon_lecture, (size_t) longueur_effective,
(*s_objet_argument_1).objet)).socket,	0, (struct sockaddr *)
tampon_lecture, longueur_effective,	&adresse_ipv6, &longueur_adresse);
0, (struct sockaddr *)	} while((ios == -1) && (errno == EINTR));
&adresse_unix, &longueur_adresse);	# else
} while((ios == -1) && (errno == EINTR));	if ((*s_etat_processus).langue == 'F')
}
else if ((((struct_socket ) (*s_objet_argument_1)
.objet)).domaine == PF_INET)
{	{
do	printf("+++Attention : Support du protocole"
{	" IPv6 indisponible\n");
longueur_adresse = sizeof(adresse_ipv4);
recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_effective,
0, (struct sockaddr *)
&adresse_ipv4, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));
}	}
else if ((((struct_socket ) (*s_objet_argument_1)	else
.objet)) .domaine == PF_INET6)
{	{
# ifdef IPV6	printf("+++Warning : IPv6 support "
do	"unavailable\n");
{
longueur_adresse = sizeof(adresse_ipv6);
recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_effective,
0, (struct sockaddr *)
&adresse_ipv6, &longueur_adresse);
} while((ios == -1) && (errno == EINTR));
# else
if ((*s_etat_processus).langue == 'F')
{
printf("+++Attention : Support du protocole"
" IPv6 indisponible\n");
}
else
{
printf("+++Warning : IPv6 support "
"unavailable\n");
}

# endif
}	}
	# endif
longueur_effective = ios;
}	}
else
{
// Installation d'un timeout pour sortir de
// l'instruction dans le cas où la transmission serait
// invalide et que la trame reçue serait erronée.

poll_fd.fd = (((struct_socket )
(*s_objet_argument_1).objet)).socket;
poll_fd.events = POLLIN;

while((ios = poll(&poll_fd, 1, 10000)) <= 0)
{
// La fin de la trame n'est pas atteinte.

switch(ios)
{
case EINTR:
{
if ((*s_etat_processus)
.var_volatile_requete_arret == -1)
{
liberation(s_etat_processus,
s_objet_argument_1);
free(tampon_lecture);
return;
}

break;
}

case 0:
{
liberation(s_etat_processus,
s_objet_argument_1);
free(tampon_lecture);

(*s_etat_processus).erreur_execution =	longueur_effective = ios;
d_ex_fin_de_fichier_atteinte;	trame_complete = d_vrai;
return;
}
}
}
}
}	}

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
Line 3208 instruction_read(struct_processus *s_eta	Line 3272 instruction_read(struct_processus *s_eta
}	}
} while(trame_complete == d_faux);	} while(trame_complete == d_faux);

tampon_lecture[++position_finale] = d_code_fin_chaine;
tampon = (*s_etat_processus).instruction_courante;
(*s_etat_processus).instruction_courante = tampon_lecture;

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)
{
(*s_etat_processus).instruction_courante = tampon;
free(tampon_lecture);

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

if ((*s_etat_processus).var_volatile_requete_arret == -1)
{
(*s_etat_processus).erreur_execution = d_ex;
}

liberation(s_etat_processus, s_objet_argument_1);
return;
}

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

(*s_etat_processus).instruction_courante = tampon;

/*	/*
* Création de la liste de sortie	* Création de la liste de sortie
*/	*/

if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),	ptr = tampon_lecture;
&s_objet_type) == d_erreur)
	if ((s_objet_type = lecture_fichier_non_formate(s_etat_processus,
	&ptr, longueur_effective, d_faux)) == NULL)
{	{
(*s_etat_processus).erreur_execution = d_ex_manque_argument;	free(tampon_lecture);

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

Line 3468 instruction_read(struct_processus *s_eta	Line 3493 instruction_read(struct_processus *s_eta
longueur_adresse = 0;	longueur_adresse = 0;
recvfrom((((struct_socket )	recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	(size_t) position_finale, MSG_DONTWAIT,
NULL, &longueur_adresse);	NULL, &longueur_adresse);
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.73
changed lines
	Added in v.1.88