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.83 and 1.108

version 1.83, 2013/09/26 15:38:38	version 1.108, 2018/12/27 22:16:47
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.16	RPL/2 (R) version 4.1.30
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2018 Dr. BERTRAND Joël

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

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 position_clef;	integer8 index;
integer8 longueur;	integer8 longueur;
	integer8 position_clef;

integer8 longueur_effective;	integer8 longueur_effective;
integer8 longueur_enregistrement;	integer8 longueur_enregistrement;
Line 867 instruction_read(struct_processus *s_eta	Line 869 instruction_read(struct_processus *s_eta

logical1 device;	logical1 device;
logical1 format_degenere;	logical1 format_degenere;
	logical1 format_oriente_ligne;
logical1 indicateur_48;	logical1 indicateur_48;
logical1 presence_chaine;	logical1 presence_chaine;
logical1 presence_indicateur;	logical1 presence_indicateur;
Line 878 instruction_read(struct_processus *s_eta	Line 881 instruction_read(struct_processus *s_eta

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 termios tc;

struct timespec attente;	struct timespec attente;

struct_descripteur_fichier *descripteur;	struct_descripteur_fichier *descripteur;
Line 906 instruction_read(struct_processus *s_eta	Line 913 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 1236 instruction_read(struct_processus *s_eta	Line 1276 instruction_read(struct_processus *s_eta
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);

	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	recherche_type(s_etat_processus);
free((*s_etat_processus).instruction_courante);	free((*s_etat_processus).instruction_courante);

Line 1291 instruction_read(struct_processus *s_eta	Line 1332 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (alsprintf(&commande, "select data from data where "	if (alsprintf(s_etat_processus, &commande,
"id = %lld", (((integer8 ) (*s_objet_argument_2)	"select data from data where id = %lld",
.objet))) < 0)	(((integer8 ) (*s_objet_argument_2).objet))) < 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 1390 instruction_read(struct_processus *s_eta	Line 1431 instruction_read(struct_processus *s_eta
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);

	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	recherche_type(s_etat_processus);

if ((*s_etat_processus).erreur_execution != d_ex)	if ((*s_etat_processus).erreur_execution != d_ex)
Line 1463 instruction_read(struct_processus *s_eta	Line 1505 instruction_read(struct_processus *s_eta

// Récupération de la position de la clef	// Récupération de la position de la clef

if (alsprintf(&commande, "select key from control "	if (alsprintf(s_etat_processus, &commande,
"where id = 1") < 0)	"select key from control where id = 1") < 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 1537 instruction_read(struct_processus *s_eta	Line 1579 instruction_read(struct_processus *s_eta

// Récupération de l'identifiant de la clef	// Récupération de l'identifiant de la clef

if (alsprintf(&commande, "select id from key where key = "	if (alsprintf(s_etat_processus, &commande,
"'{ \"%s\" }'", clef_utf8) < 0)	"select id from key where key = '{ \"%s\" }'",
	clef_utf8) < 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 1630 instruction_read(struct_processus *s_eta	Line 1673 instruction_read(struct_processus *s_eta

free(commande);	free(commande);

if (alsprintf(&commande, "select data from data where "	if (alsprintf(s_etat_processus, &commande,
	"select data from data where "
"key_id = %lld order by sequence asc", id) < 0)	"key_id = %lld order by sequence asc", id) < 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 1697 instruction_read(struct_processus *s_eta	Line 1741 instruction_read(struct_processus *s_eta
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);

	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	recherche_type(s_etat_processus);

if ((*s_etat_processus).erreur_execution != d_ex)	if ((*s_etat_processus).erreur_execution != d_ex)
Line 1759 instruction_read(struct_processus *s_eta	Line 1804 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (alsprintf(&tampon2, "{ \"%s\" }",	if (alsprintf(s_etat_processus, &tampon2,
(*s_etat_processus)	"{ \"%s\" }", (*s_etat_processus)
.instruction_courante) < 0)	.instruction_courante) < 0)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 1775 instruction_read(struct_processus *s_eta	Line 1820 instruction_read(struct_processus *s_eta
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);

	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	recherche_type(s_etat_processus);

if ((*s_etat_processus).erreur_execution	if ((*s_etat_processus).erreur_execution
Line 1974 instruction_read(struct_processus *s_eta	Line 2020 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;	device = d_faux;

if ((position_initiale = ftell((*descripteur).descripteur_c))	if ((position_initiale = ftell((*descripteur).descripteur_c))
Line 2016 instruction_read(struct_processus *s_eta	Line 2063 instruction_read(struct_processus *s_eta
return;	return;
}	}

if ((format_chaine = conversion_majuscule((unsigned char *)	if ((format_chaine = conversion_majuscule(
	s_etat_processus, (unsigned char *)
((l_element_courant_format).donnee).objet))	((l_element_courant_format).donnee).objet))
== NULL)	== NULL)
{	{
Line 2025 instruction_read(struct_processus *s_eta	Line 2073 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (strncmp("LENGTH*(", format_chaine, 8) != 0)	if (strcmp("LINE()", format_chaine) == 0)
{	{
liberation(s_etat_processus, s_objet_argument_1);	format_degenere = d_vrai;
liberation(s_etat_processus, s_objet_resultat);	format_oriente_ligne = d_vrai;
free(format_chaine);

(*s_etat_processus).erreur_execution =
d_ex_erreur_format_fichier;
return;
}	}
	else
longueur = (integer8) strlen(format_chaine);

if (format_chaine[longueur - 1] != ')')
{	{
liberation(s_etat_processus, s_objet_argument_1);	format_oriente_ligne = d_faux;
liberation(s_etat_processus, s_objet_resultat);
free(format_chaine);

(*s_etat_processus).erreur_execution =	if (strncmp("LENGTH*(", format_chaine, 8) != 0)
d_ex_erreur_format_fichier;	{
return;	liberation(s_etat_processus, s_objet_argument_1);
}	liberation(s_etat_processus, s_objet_resultat);
	free(format_chaine);

format_chaine[longueur] = d_code_fin_chaine;	(*s_etat_processus).erreur_execution =
	d_ex_erreur_format_fichier;
	return;
	}

if (format_chaine[8] == '*')	longueur = (integer8) strlen(format_chaine);
{
format_degenere = d_vrai;
}
else
{
// Détermination de la longueur
format_degenere = d_faux;

if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1)	if (format_chaine[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 2070 instruction_read(struct_processus *s_eta	Line 2105 instruction_read(struct_processus *s_eta
d_ex_erreur_format_fichier;	d_ex_erreur_format_fichier;
return;	return;
}	}

	format_chaine[longueur] = d_code_fin_chaine;

	if (format_chaine[8] == '*')
	{
	format_degenere = d_vrai;
	}
	else
	{
	// Détermination de la longueur
	format_degenere = d_faux;

	if (sscanf(&(format_chaine[8]), "%lld", &longueur)
	!= 1)
	{
	liberation(s_etat_processus, s_objet_argument_1);
	liberation(s_etat_processus, s_objet_resultat);
	free(format_chaine);

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

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;
	}
	}
	}
	else
	{
	// Évite un warning de gcc.
	longueur_questure = 0;
	index = 0;
	timeout = 0;
	}

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 (device == d_vrai)
	{
	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;
	}

	if (format_oriente_ligne == d_vrai)
	{
	if (c == '\n')
	{
	break;
	}
	}
	} while(c != EOF);

if (device == d_faux)	if (device == d_faux)
{	{
Line 2102 instruction_read(struct_processus *s_eta	Line 2243 instruction_read(struct_processus *s_eta
longueur_enregistrement = longueur;	longueur_enregistrement = longueur;
}	}

if ((tampon_lecture = malloc(((size_t)	if ((device == d_vrai) && (format_degenere == d_vrai))
longueur_enregistrement) * 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 = (integer8) fread(tampon_lecture,	longueur_effective = (integer8) fread(tampon_lecture,
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 2154 instruction_read(struct_processus *s_eta	Line 2303 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 2628 instruction_read(struct_processus *s_eta	Line 2789 instruction_read(struct_processus *s_eta
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);

	(*s_etat_processus).type_en_cours = NON;
recherche_type(s_etat_processus);	recherche_type(s_etat_processus);

if ((*s_etat_processus).erreur_execution != d_ex)	if ((*s_etat_processus).erreur_execution != d_ex)
Line 3380 instruction_read(struct_processus *s_eta	Line 3542 instruction_read(struct_processus *s_eta
}	}
else	else
{ // FLOW	{ // FLOW
#if 0
longueur_questure = 256;	longueur_questure = 256;

do	do
{	{
if ((tampon_lecture = malloc((longueur_questure + 1) *	if ((tampon_lecture = malloc((((size_t) longueur_questure) + 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;
Line 3414 instruction_read(struct_processus *s_eta	Line 3575 instruction_read(struct_processus *s_eta
longueur_adresse = sizeof(adresse_unix);	longueur_adresse = sizeof(adresse_unix);
longueur_effective = recvfrom((((struct_socket )	longueur_effective = recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_questure,	tampon_lecture, (long unsigned int)
	longueur_questure,
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_unix, &longueur_adresse);	&adresse_unix, &longueur_adresse);
}	}
Line 3424 instruction_read(struct_processus *s_eta	Line 3586 instruction_read(struct_processus *s_eta
longueur_adresse = sizeof(adresse_ipv4);	longueur_adresse = sizeof(adresse_ipv4);
longueur_effective = recvfrom((((struct_socket )	longueur_effective = recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_questure,	tampon_lecture, (long unsigned int)
	longueur_questure,
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv4, &longueur_adresse);	&adresse_ipv4, &longueur_adresse);
}	}
Line 3435 instruction_read(struct_processus *s_eta	Line 3598 instruction_read(struct_processus *s_eta
longueur_adresse = sizeof(adresse_ipv6);	longueur_adresse = sizeof(adresse_ipv6);
longueur_effective = recvfrom((((struct_socket )	longueur_effective = recvfrom((((struct_socket )
(*s_objet_argument_1).objet)).socket,	(*s_objet_argument_1).objet)).socket,
tampon_lecture, longueur_questure,	tampon_lecture, (long unsigned int)
	longueur_questure,
MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)	MSG_PEEK \| MSG_DONTWAIT, (struct sockaddr *)
&adresse_ipv6, &longueur_adresse);	&adresse_ipv6, &longueur_adresse);
# else	# else
Line 3563 instruction_read(struct_processus *s_eta	Line 3727 instruction_read(struct_processus *s_eta
return;	return;
}	}

if (((s_objet_type).objet = malloc(longueur_enregistrement	if (((*s_objet_type).objet = malloc((size_t) longueur_enregistrement
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;
Line 3647 instruction_read(struct_processus *s_eta	Line 3811 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,	(long unsigned int) longueur_effective, MSG_DONTWAIT,
NULL, &longueur_adresse);	NULL, &longueur_adresse);

(*s_objet_adresse).objet = NULL;	(*s_objet_adresse).objet = NULL;
Line 3658 instruction_read(struct_processus *s_eta	Line 3822 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, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	(long unsigned int) longueur_effective, MSG_DONTWAIT,
(struct sockaddr *) &adresse_ipv4, &longueur_adresse);	(struct sockaddr *) &adresse_ipv4, &longueur_adresse);

if (((*s_objet_adresse).objet =	if (((*s_objet_adresse).objet =
Line 3738 instruction_read(struct_processus *s_eta	Line 3902 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, tampon_lecture,	(*s_objet_argument_1).objet)).socket, tampon_lecture,
position_finale, MSG_DONTWAIT,	(long unsigned int) longueur_effective, MSG_DONTWAIT,
(struct sockaddr *) &adresse_ipv6, &longueur_adresse);	(struct sockaddr *) &adresse_ipv6, &longueur_adresse);

if (((*s_objet_adresse).objet =	if (((*s_objet_adresse).objet =
Line 3819 instruction_read(struct_processus *s_eta	Line 3983 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,	(long unsigned int) longueur_effective, MSG_DONTWAIT,
NULL, &longueur_adresse);	NULL, &longueur_adresse);
}	}

Line 3830 instruction_read(struct_processus *s_eta	Line 3994 instruction_read(struct_processus *s_eta
{	{
return;	return;
}	}
#endif
}	}
}	}
else	else

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.83
changed lines
	Added in v.1.108