rpl/src/formateur_fichiers.c - diff

Return to formateur_fichiers.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/formateur_fichiers.c between versions 1.58 and 1.66

version 1.58, 2013/03/19 11:46:11	version 1.66, 2013/03/23 18:00:09
Line 40	Line 40

unsigned char *	unsigned char *
formateur_fichier(struct_processus s_etat_processus, struct_objet s_objet,	formateur_fichier(struct_processus s_etat_processus, struct_objet s_objet,
struct_objet *s_format, long longueur, long longueur_champ,	struct_objet *s_format, integer8 longueur, integer8 longueur_champ,
unsigned char format_sortie, unsigned char type,	unsigned char format_sortie, unsigned char type,
long longueur_effective, long recursivite, logical1 export_fichier)	integer8 longueur_effective, integer8 recursivite,
	logical1 export_fichier)
{	{
/*	/*
* Traitement du format des fichiers formatés :	* Traitement du format des fichiers formatés :
Line 78 formateur_fichier(struct_processus *s_et	Line 79 formateur_fichier(struct_processus *s_et
logical1 format_degenere;	logical1 format_degenere;
logical1 presence_signe;	logical1 presence_signe;

unsigned long int longueur_chaine_traitee;

struct_liste_chainee *l_atome;	struct_liste_chainee *l_atome;
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_courant_format;	struct_liste_chainee *l_element_courant_format;
Line 103 formateur_fichier(struct_processus *s_et	Line 102 formateur_fichier(struct_processus *s_et
unsigned char tampon[64 + 1];	unsigned char tampon[64 + 1];
unsigned char type_binaire;	unsigned char type_binaire;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long nombre_arguments;	integer8 nombre_arguments;
unsigned long nombre_arguments_fonction;	integer8 nombre_arguments_fonction;
unsigned long nombre_colonnes;	integer8 nombre_colonnes;
unsigned long nombre_elements;	integer8 nombre_elements;
unsigned long nombre_lignes;	integer8 nombre_lignes;

	integer8 longueur_chaine_traitee;
integer8 longueur_fonction;	integer8 longueur_fonction;
integer8 longueur_liste;	integer8 longueur_liste;
integer8 longueur_reelle_chaine;	integer8 longueur_reelle_chaine;
Line 928 formateur_fichier(struct_processus *s_et	Line 928 formateur_fichier(struct_processus *s_et
ptrl = chaine_sauvegarde;	ptrl = chaine_sauvegarde;
ptre = (unsigned char ) (s_sous_objet).objet;	ptre = (unsigned char ) (s_sous_objet).objet;

for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;	for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde))
i--, ptre++ = ptrl++);	- 2; i > 0; i--, ptre++ = ptrl++);

(*ptre) = d_code_fin_chaine;	(*ptre) = d_code_fin_chaine;

Line 1026 formateur_fichier(struct_processus *s_et	Line 1026 formateur_fichier(struct_processus *s_et
strcpy(chaine, tampon);	strcpy(chaine, tampon);
tampon[0] = 0;	tampon[0] = 0;

for(i = 0; i < strlen(chaine); i++)	for(i = 0; i < ((integer8) strlen(chaine)); i++)
{	{
switch(chaine[i])	switch(chaine[i])
{	{
Line 1156 formateur_fichier(struct_processus *s_et	Line 1156 formateur_fichier(struct_processus *s_et
if ((longueur_champ > 0) && (longueur_champ	if ((longueur_champ > 0) && (longueur_champ
< (signed) strlen(tampon)))	< (signed) strlen(tampon)))
{	{
ptrl = &(tampon[strlen(tampon) - longueur_champ]);	ptrl = &(tampon[((integer8) strlen(tampon))
	- longueur_champ]);
ptre = tampon;	ptre = tampon;

do	do
Line 1228 formateur_fichier(struct_processus *s_et	Line 1229 formateur_fichier(struct_processus *s_et
(*s_objet).objet, longueur_champ)	(*s_objet).objet, longueur_champ)
- ((unsigned char ) (s_objet).objet);	- ((unsigned char ) (s_objet).objet);

if ((chaine = malloc((longueur_reelle_chaine + 1) *	if ((chaine = malloc((((size_t) longueur_reelle_chaine) + 1) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 1237 formateur_fichier(struct_processus *s_et	Line 1238 formateur_fichier(struct_processus *s_et
}	}

strncpy(chaine, (unsigned char ) ((s_objet).objet),	strncpy(chaine, (unsigned char ) ((s_objet).objet),
longueur_reelle_chaine);	(size_t) longueur_reelle_chaine);
chaine[longueur_reelle_chaine] = d_code_fin_chaine;	chaine[longueur_reelle_chaine] = d_code_fin_chaine;
}	}
}	}
Line 1588 formateur_fichier(struct_processus *s_et	Line 1589 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

position_3 = strlen(format_chaine) - 1;	position_3 = ((integer8) strlen(format_chaine)) - 1;

if (format_chaine[position_3] != ')')	if (format_chaine[position_3] != ')')
{	{
Line 1623 formateur_fichier(struct_processus *s_et	Line 1624 formateur_fichier(struct_processus *s_et

if (format_degenere == d_faux)	if (format_degenere == d_faux)
{	{
if (sscanf(&(format_chaine[position_1]), "%ld",	if (sscanf(&(format_chaine[position_1]), "%lld",
&longueur) != 1)	&longueur) != 1)
{	{
free(chaine);	free(chaine);
Line 1641 formateur_fichier(struct_processus *s_et	Line 1642 formateur_fichier(struct_processus *s_et

if (strcmp(&(format_chaine[position_2]), "*") != 0)	if (strcmp(&(format_chaine[position_2]), "*") != 0)
{	{
if (sscanf(&(format_chaine[position_2]), "%ld",	if (sscanf(&(format_chaine[position_2]), "%lld",
&longueur_champ) != 1)	&longueur_champ) != 1)
{	{
free(chaine);	free(chaine);
Line 1936 formateur_fichier(struct_processus *s_et	Line 1937 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

position_3 = strlen(format_chaine);	position_3 = (integer8) strlen(format_chaine);
format_chaine[--position_3] = d_code_fin_chaine;	format_chaine[--position_3] = d_code_fin_chaine;

position_2 = position_1;	position_2 = position_1;
Line 1960 formateur_fichier(struct_processus *s_et	Line 1961 formateur_fichier(struct_processus *s_et

if (format_degenere == d_faux)	if (format_degenere == d_faux)
{	{
if (sscanf(&(format_chaine[position_1]), "%ld",	if (sscanf(&(format_chaine[position_1]), "%lld",
&longueur) != 1)	&longueur) != 1)
{	{
free(chaine);	free(chaine);
Line 1978 formateur_fichier(struct_processus *s_et	Line 1979 formateur_fichier(struct_processus *s_et

if (strcmp(&(format_chaine[position_2]), "*") != 0)	if (strcmp(&(format_chaine[position_2]), "*") != 0)
{	{
if (sscanf(&(format_chaine[position_2]), "%ld",	if (sscanf(&(format_chaine[position_2]), "%lld",
&longueur_champ) != 1)	&longueur_champ) != 1)
{	{
free(chaine);	free(chaine);
Line 2874 formateur_fichier(struct_processus *s_et	Line 2875 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

(*longueur_effective) = strlen(chaine) + 1;	(*longueur_effective) = ((integer8) strlen(chaine)) + 1;
}	}
else	else
{	{
Line 3087 formateur_fichier(struct_processus *s_et	Line 3088 formateur_fichier(struct_processus *s_et

(*longueur_effective) = longueur_champ + 1;	(*longueur_effective) = longueur_champ + 1;

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

chaine[0] = longueur_champ;	chaine[0] = (unsigned char) longueur_champ;

for(i = 1; i <= (unsigned) (*longueur_effective); i++)	for(i = 1; i <= (*longueur_effective); i++)
{	{
chaine[i] = ((((logical8 ) (*s_objet).objet)) >>	chaine[i] = ((((logical8 ) (*s_objet).objet)) >>
(8 * (longueur_champ - i))) & 0xFF;	(8 * (longueur_champ - i))) & 0xFF;
Line 3152 formateur_fichier(struct_processus *s_et	Line 3153 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

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

memcpy(chaine, chaine_sauvegarde, longueur_champ);	memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ);
longueur_chaine_traitee = longueur_champ;	longueur_chaine_traitee = longueur_champ;
free(chaine_sauvegarde);	free(chaine_sauvegarde);
}	}
Line 3169 formateur_fichier(struct_processus *s_et	Line 3170 formateur_fichier(struct_processus *s_et

if (longueur_chaine_traitee < (1LL << 3))	if (longueur_chaine_traitee < (1LL << 3))
{	{
if ((chaine = malloc((longueur_chaine_traitee + 1)	if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3177 formateur_fichier(struct_processus *s_et	Line 3178 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0x80 \| (longueur_chaine_traitee & 0x7);	chaine[0] = (unsigned char) (0x80 \|
	(longueur_chaine_traitee & 0x7));

memcpy(chaine + 1, chaine_sauvegarde, longueur_chaine_traitee);	memcpy(chaine + 1, chaine_sauvegarde,
	(size_t) longueur_chaine_traitee);
longueur_totale = longueur_chaine_traitee + 1;	longueur_totale = longueur_chaine_traitee + 1;
}	}
else if (longueur_chaine_traitee < (1LL << 8))	else if (longueur_chaine_traitee < (1LL << 8))
{	{
if ((chaine = malloc((longueur_chaine_traitee + 2)	if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3192 formateur_fichier(struct_processus *s_et	Line 3195 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0x88;	chaine[0] = (unsigned char) 0x88;
chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);	chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);

memcpy(chaine + 2, chaine_sauvegarde, longueur_chaine_traitee);	memcpy(chaine + 2, chaine_sauvegarde,
	(size_t) longueur_chaine_traitee);
longueur_totale = longueur_chaine_traitee + 2;	longueur_totale = longueur_chaine_traitee + 2;
}	}
else if (longueur_chaine_traitee < (1LL << 16))	else if (longueur_chaine_traitee < (1LL << 16))
{	{
if ((chaine = malloc((longueur_chaine_traitee + 3)	if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3208 formateur_fichier(struct_processus *s_et	Line 3212 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0x89;	chaine[0] = (unsigned char) 0x89;
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)	chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)
& 0xFF);	& 0xFF);
chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);	chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);

memcpy(chaine + 3, chaine_sauvegarde, longueur_chaine_traitee);	memcpy(chaine + 3, chaine_sauvegarde,
	(size_t) longueur_chaine_traitee);
longueur_totale = longueur_chaine_traitee + 3;	longueur_totale = longueur_chaine_traitee + 3;
}	}
else if (longueur_chaine_traitee < (1LL << 32))	else if (longueur_chaine_traitee < (1LL << 32))
{	{
if ((chaine = malloc((longueur_chaine_traitee + 5)	if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3226 formateur_fichier(struct_processus *s_et	Line 3231 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0x8A;	chaine[0] = (unsigned char) 0x8A;
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)	chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)
& 0xFF);	& 0xFF);
chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)	chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)
Line 3235 formateur_fichier(struct_processus *s_et	Line 3240 formateur_fichier(struct_processus *s_et
& 0xFF);	& 0xFF);
chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);	chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);

memcpy(chaine + 5, chaine_sauvegarde, longueur_chaine_traitee);	memcpy(chaine + 5, chaine_sauvegarde,
	(size_t) longueur_chaine_traitee);
longueur_totale = longueur_chaine_traitee + 5;	longueur_totale = longueur_chaine_traitee + 5;
}	}
else	else
{	{
if ((chaine = malloc((longueur_chaine_traitee + 9)	if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3248 formateur_fichier(struct_processus *s_et	Line 3254 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0x8B;	chaine[0] = (unsigned char) 0x8B;
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)	chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)
& 0xFF);	& 0xFF);
chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)	chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)
Line 3265 formateur_fichier(struct_processus *s_et	Line 3271 formateur_fichier(struct_processus *s_et
& 0xFF);	& 0xFF);
chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);	chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);

memcpy(chaine + 9, chaine_sauvegarde, longueur_chaine_traitee);	memcpy(chaine + 9, chaine_sauvegarde,
	(size_t) longueur_chaine_traitee);
longueur_totale = longueur_chaine_traitee + 9;	longueur_totale = longueur_chaine_traitee + 9;
}	}

Line 3349 formateur_fichier(struct_processus *s_et	Line 3356 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

longueur_fonction = strlen((((struct_fonction ) (*s_objet).objet))	longueur_fonction = (integer8) strlen((((struct_fonction )
.nom_fonction);	(*s_objet).objet)).nom_fonction);

if (longueur_fonction < (1LL << 3))	if (longueur_fonction < (1LL << 3))
{	{
if ((chaine = malloc((1 + longueur_fonction + 8)	if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3362 formateur_fichier(struct_processus *s_et	Line 3369 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0xE0 \| (longueur_fonction & 0x7);	chaine[0] = (unsigned char) (0xE0 \| (longueur_fonction & 0x7));

strcpy(chaine + 1, (((struct_fonction ) (*s_objet).objet))	strcpy(chaine + 1, (((struct_fonction ) (*s_objet).objet))
.nom_fonction);	.nom_fonction);
	(*longueur_effective) = 1 + longueur_fonction + 8;
}	}
else if (longueur_fonction < (1LL << 8))	else if (longueur_fonction < (1LL << 8))
{	{
if ((chaine = malloc((2 + longueur_fonction + 8)	if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3377 formateur_fichier(struct_processus *s_et	Line 3385 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0xE0 \| 0x08;	chaine[0] = (unsigned char) (0xE0 \| 0x08);
chaine[1] = (unsigned char) (longueur_fonction & 0xFF);	chaine[1] = (unsigned char) (longueur_fonction & 0xFF);

strcpy(chaine + 2, (((struct_fonction ) (*s_objet).objet))	strcpy(chaine + 2, (((struct_fonction ) (*s_objet).objet))
.nom_fonction);	.nom_fonction);
	(*longueur_effective) = 2 + longueur_fonction + 8;
}	}
else if (longueur_fonction < (1LL << 16))	else if (longueur_fonction < (1LL << 16))
{	{
if ((chaine = malloc((3 + longueur_fonction + 8)	if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3393 formateur_fichier(struct_processus *s_et	Line 3402 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0xE0 \| 0x09;	chaine[0] = (unsigned char ) (0xE0 \| 0x09);
chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);	chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
chaine[2] = (unsigned char) (longueur_fonction & 0xFF);	chaine[2] = (unsigned char) (longueur_fonction & 0xFF);

strcpy(chaine + 3, (((struct_fonction ) (*s_objet).objet))	strcpy(chaine + 3, (((struct_fonction ) (*s_objet).objet))
.nom_fonction);	.nom_fonction);
	(*longueur_effective) = 3 + longueur_fonction + 9;
}	}
else if (longueur_fonction < (1LL << 32))	else if (longueur_fonction < (1LL << 32))
{	{
if ((chaine = malloc((5 + longueur_fonction + 8)	if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3410 formateur_fichier(struct_processus *s_et	Line 3420 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0xE0 \| 0x0A;	chaine[0] = (unsigned char) (0xE0 \| 0x0A);
chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);	chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);	chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);	chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
Line 3418 formateur_fichier(struct_processus *s_et	Line 3428 formateur_fichier(struct_processus *s_et

strcpy(chaine + 5, (((struct_fonction ) (*s_objet).objet))	strcpy(chaine + 5, (((struct_fonction ) (*s_objet).objet))
.nom_fonction);	.nom_fonction);
	(*longueur_effective) = 5 + longueur_fonction + 8;
}	}
else	else
{	{
if ((chaine = malloc((9 + longueur_fonction + 8)	if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3429 formateur_fichier(struct_processus *s_et	Line 3440 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0xE0 \| 0x0B;	chaine[0] = (unsigned char) (0xE0 \| 0x0B);
chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);	chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);	chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);	chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
Line 3441 formateur_fichier(struct_processus *s_et	Line 3452 formateur_fichier(struct_processus *s_et

strcpy(chaine + 9, (((struct_fonction ) (*s_objet).objet))	strcpy(chaine + 9, (((struct_fonction ) (*s_objet).objet))
.nom_fonction);	.nom_fonction);
	(*longueur_effective) = 9 + longueur_fonction + 8;
}	}

for(i = 1; i <= 8; i++)	for(i = 1; i <= 8; i++)
{	{
chaine[longueur_fonction + i] = (unsigned char)	chaine[(*longueur_effective) - i] = (unsigned char)
(((((struct_fonction ) (*s_objet).objet))	(((((struct_fonction ) (*s_objet).objet))
.nombre_arguments >> ((8 - i) * 8)) & 0xFF);	.nombre_arguments >> ((8 - i) * 8)) & 0xFF);
}	}

(*longueur_effective) = longueur_fonction + 9;
}	}
else if (((s_objet).type == LST) \|\| ((s_objet).type == ALG)	else if (((s_objet).type == LST) \|\| ((s_objet).type == ALG)
\|\| ((*s_objet).type == RPN))	\|\| ((*s_objet).type == RPN))
Line 3503 formateur_fichier(struct_processus *s_et	Line 3513 formateur_fichier(struct_processus *s_et

if (longueur_liste < (1LL << 3))	if (longueur_liste < (1LL << 3))
{	{
chaine[0] = type_binaire \| (longueur_liste & 0x7);	chaine[0] = (unsigned char) (type_binaire \|
	(longueur_liste & 0x7));
}	}
else if (longueur_liste < (1LL << 8))	else if (longueur_liste < (1LL << 8))
{	{
chaine[0] = type_binaire \| 0x08;	chaine[0] = (unsigned char) (type_binaire \| 0x08);
}	}
else if (longueur_liste < (1LL << 16))	else if (longueur_liste < (1LL << 16))
{	{
chaine[0] = type_binaire \| 0x09;	chaine[0] = (unsigned char ) (type_binaire \| 0x09);
}	}
else if (longueur_liste < (1LL << 32))	else if (longueur_liste < (1LL << 32))
{	{
chaine[0] = type_binaire \| 0x0A;	chaine[0] = (unsigned char) (type_binaire \| 0x0A);
}	}
else	else
{	{
chaine[0] = type_binaire \| 0x0B;	chaine[0] = (unsigned char) (type_binaire \| 0x0B);
}	}

longueur_totale = 1;	longueur_totale = 1;
Line 3532 formateur_fichier(struct_processus *s_et	Line 3543 formateur_fichier(struct_processus *s_et
{	{
longueur_totale += 1;	longueur_totale += 1;

if ((chaine = realloc(chaine, longueur_totale *	if ((chaine = realloc(chaine,
	((size_t) longueur_totale) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3549 formateur_fichier(struct_processus *s_et	Line 3561 formateur_fichier(struct_processus *s_et
{	{
longueur_totale += 2;	longueur_totale += 2;

if ((chaine = realloc(chaine, longueur_totale *	if ((chaine = realloc(chaine,
	((size_t) longueur_totale) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3568 formateur_fichier(struct_processus *s_et	Line 3581 formateur_fichier(struct_processus *s_et
{	{
longueur_totale += 4;	longueur_totale += 4;

if ((chaine = realloc(chaine, longueur_totale *	if ((chaine = realloc(chaine,
	((size_t) longueur_totale) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3591 formateur_fichier(struct_processus *s_et	Line 3605 formateur_fichier(struct_processus *s_et
{	{
longueur_totale += 8;	longueur_totale += 8;

if ((chaine = realloc(chaine, longueur_totale *	if ((chaine = realloc(chaine,
	((size_t) longueur_totale) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3638 formateur_fichier(struct_processus *s_et	Line 3653 formateur_fichier(struct_processus *s_et
((((l_element_courant_format).donnee).type == TBL)	((((l_element_courant_format).donnee).type == TBL)
&& (((l_element_courant).donnee).type == TBL)))	&& (((l_element_courant).donnee).type == TBL)))
{	{
if ((chaine_formatee = formateur_fichier(s_etat_processus,	if (format_sortie != 'N')
(*l_element_courant).donnee,
(*l_element_courant_format).donnee, 0, 0, ' ', 'U',
longueur_effective, recursivite, export_fichier))
== NULL)
{	{
return(NULL);	if ((chaine_formatee = formateur_fichier(
	s_etat_processus,
	(*l_element_courant).donnee,
	(*l_element_courant_format).donnee,
	0, 0, ' ', 'U', longueur_effective, recursivite,
	export_fichier)) == NULL)
	{
	return(NULL);
	}
	}
	else
	{
	if ((chaine_formatee = formateur_fichier(
	s_etat_processus,
	(*l_element_courant).donnee,
	(*l_element_courant_format).donnee,
	0, 0, 'N', 'U', longueur_effective, recursivite,
	export_fichier)) == NULL)
	{
	return(NULL);
	}
}	}

if ((chaine = realloc(chaine, (longueur_totale +	if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
(longueur_effective)) sizeof(unsigned char)))	(longueur_effective))) sizeof(unsigned char)))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3657 formateur_fichier(struct_processus *s_et	Line 3688 formateur_fichier(struct_processus *s_et
}	}

memcpy(&(chaine[longueur_totale]), chaine_formatee,	memcpy(&(chaine[longueur_totale]), chaine_formatee,
(*longueur_effective));	(size_t) (*longueur_effective));
longueur_totale += (*longueur_effective);	longueur_totale += (*longueur_effective);
free(chaine_formatee);	free(chaine_formatee);
}	}
Line 3734 formateur_fichier(struct_processus *s_et	Line 3765 formateur_fichier(struct_processus *s_et

if (strcmp(&(format_chaine[position_1]), "(*)") != 0)	if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
{	{
if (sscanf(&(format_chaine[position_1]), "%ld",	if (sscanf(&(format_chaine[position_1]), "%lld",
&longueur) != 1)	&longueur) != 1)
{	{
free(chaine);	free(chaine);
Line 3766 formateur_fichier(struct_processus *s_et	Line 3797 formateur_fichier(struct_processus *s_et
}	}

if ((chaine = realloc(chaine,	if ((chaine = realloc(chaine,
(longueur_totale + (*longueur_effective))	((size_t) (longueur_totale + (*longueur_effective)))
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3775 formateur_fichier(struct_processus *s_et	Line 3806 formateur_fichier(struct_processus *s_et
}	}

memcpy(&(chaine[longueur_totale]), chaine_formatee,	memcpy(&(chaine[longueur_totale]), chaine_formatee,
(*longueur_effective));	(size_t) (*longueur_effective));
longueur_totale += (*longueur_effective);	longueur_totale += (*longueur_effective);
free(chaine_formatee);	free(chaine_formatee);
}	}

nombre_elements++;	nombre_elements++;
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
l_element_courant_format = (*l_element_courant_format).suivant;
	if (format_sortie != 'N')
	{
	l_element_courant_format =
	(*l_element_courant_format).suivant;
	}
}	}

if ((l_element_courant != NULL) \|\|	if (format_sortie != 'N')
(l_element_courant_format != NULL))
{	{
free(chaine);	if ((l_element_courant != NULL) \|\|
	(l_element_courant_format != NULL))
	{
	free(chaine);

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

(*longueur_effective) = longueur_totale;	(*longueur_effective) = longueur_totale;
Line 3839 formateur_fichier(struct_processus *s_et	Line 3878 formateur_fichier(struct_processus *s_et
/*	/*
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Nom	Nom
	Poids fort 0101
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/
	if (format_sortie != 'N')
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_format_fichier;
	return(NULL);
	}

	longueur_fonction = (integer8) strlen((((struct_nom )
	(*s_objet).objet)).nom);

	if (longueur_fonction < (1LL << 3))
	{
	if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1)
	* sizeof(unsigned char)))== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = (unsigned char) (0x50 \| (longueur_fonction & 0x7));

	strcpy(chaine + 1, (((struct_nom ) (*s_objet).objet)).nom);
	(*longueur_effective) = longueur_fonction + 2;
	}
	else if (longueur_fonction < (1LL << 8))
	{
	if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 1)
	* sizeof(unsigned char)))== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = (unsigned char) (0x50 \| 0x08);
	chaine[1] = (unsigned char) (longueur_fonction & 0xFF);

	strcpy(chaine + 2, (((struct_nom ) (*s_objet).objet)).nom);
	(*longueur_effective) = longueur_fonction + 3;
	}
	else if (longueur_fonction < (1LL << 16))
	{
	if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1)
	* sizeof(unsigned char)))== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = (unsigned char) (0x50 \| 0x09);
	chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
	chaine[2] = (unsigned char) (longueur_fonction & 0xFF);

	strcpy(chaine + 3, (((struct_nom ) (*s_objet).objet)).nom);
	(*longueur_effective) = longueur_fonction + 4;
	}
	else if (longueur_fonction < (1LL << 32))
	{
	if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1)
	* sizeof(unsigned char)))== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = (unsigned char) (0xE0 \| 0x0A);
	chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
	chaine[4] = (unsigned char) (longueur_fonction & 0xFF);

	strcpy(chaine + 5, (((struct_nom ) (*s_objet).objet)).nom);
	(*longueur_effective) = longueur_fonction + 6;
	}
	else
	{
	if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1)
	* sizeof(unsigned char)))== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = (unsigned char) (0xE0 \| 0x0B);
	chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
	chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
	chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
	chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
	chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
	chaine[8] = (unsigned char) (longueur_fonction & 0xFF);

	strcpy(chaine + 9, (((struct_nom ) (*s_objet).objet)).nom);
	(*longueur_effective) = longueur_fonction + 10;
	}

	chaine[(longueur_effective) - 1] = ((((struct_nom *)
	(*s_objet).objet)).symbole == d_vrai) ? 0xFF : 0x00;
}	}
else if ((*s_objet).type == REL)	else if ((*s_objet).type == REL)
{	{
Line 3920 formateur_fichier(struct_processus *s_et	Line 4063 formateur_fichier(struct_processus *s_et

if (longueur_totale < (((integer8) 1) << 7))	if (longueur_totale < (((integer8) 1) << 7))
{	{
tampon[0] = ((longueur_totale + 1) << 1) & 0xFF;	tampon[0] = (unsigned char) (((longueur_totale + 1) << 1)
	& 0xFF);

if ((chaine = realloc(chaine, (longueur_totale + 1)	if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3944 formateur_fichier(struct_processus *s_et	Line 4088 formateur_fichier(struct_processus *s_et
\|\| (i == 6))	\|\| (i == 6))
{	{
// LSB (4 bits de poids fort)	// LSB (4 bits de poids fort)
tampon[0] = (longueur_totale & 0xF0)	tampon[0] = (unsigned char) ((longueur_totale & 0xF0)
\| 0x1 /* longueur supérieure à 7 bits */	\| 0x1 /* longueur supérieure à 7 bits */
\| ((i + 1) << 1);	\| ((i + 1) << 1));

for(j = 0; j <= i; j++)	for(j = 0; j <= i; j++)
{	{
tampon[(i - j) + 1] =	tampon[(i - j) + 1] = (unsigned char)
(longueur_totale >> (8 * (j + 1)))	((longueur_totale >> (8 * (j + 1)))
& 0xFF;	& 0xFF);
}	}

// LSB (4 bits de poids faible)	// LSB (4 bits de poids faible)
tampon[i + 2] = ((longueur_totale & 0x0F) << 4)	tampon[i + 2] = (unsigned char)
	(((longueur_totale & 0x0F) << 4)
\| 0x1 /* longueur supérieure à 7 bits */	\| 0x1 /* longueur supérieure à 7 bits */
\| ((i + 1) << 1);	\| ((i + 1) << 1));
break;	break;
}	}
}	}

if ((chaine = realloc(chaine, (longueur_totale + 3)	if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 3)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 4012 formateur_fichier(struct_processus *s_et	Line 4157 formateur_fichier(struct_processus *s_et
unsigned char *	unsigned char *
formateur_fichier_nombre(struct_processus *s_etat_processus,	formateur_fichier_nombre(struct_processus *s_etat_processus,
void *valeur_numerique, unsigned char type,	void *valeur_numerique, unsigned char type,
long longueur, long longueur_champ, unsigned char format)	integer8 longueur, integer8 longueur_champ, unsigned char format)
{	{
unsigned char *chaine;	unsigned char *chaine;
unsigned char *construction_chaine;	unsigned char *construction_chaine;
Line 4152 formateur_fichier_nombre(struct_processu	Line 4297 formateur_fichier_nombre(struct_processu
unsigned char *	unsigned char *
formateur_fichier_reel(struct_processus *s_etat_processus,	formateur_fichier_reel(struct_processus *s_etat_processus,
void *valeur_numerique, unsigned char type,	void *valeur_numerique, unsigned char type,
long longueur, long longueur_champ,	integer8 longueur, integer8 longueur_champ,
unsigned char format_sortie)	unsigned char format_sortie)
{	{
real8 mantisse;	real8 mantisse;
real8 tampon_reel;	real8 tampon_reel;

	integer8 i;
integer8 tampon_entier;	integer8 tampon_entier;

long correction;	long correction;
Line 4170 formateur_fichier_reel(struct_processus	Line 4316 formateur_fichier_reel(struct_processus
unsigned char mode[3 + 1];	unsigned char mode[3 + 1];
unsigned char tampon[16 + 1];	unsigned char tampon[16 + 1];

unsigned long i;

chaine = (unsigned char ) malloc((32 + 1) sizeof(unsigned char));	chaine = (unsigned char ) malloc((32 + 1) sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 4197 formateur_fichier_reel(struct_processus	Line 4341 formateur_fichier_reel(struct_processus
exposant = 0;	exposant = 0;
}	}

mantisse = (((real8 ) valeur_numerique)) / pow(10, exposant);	mantisse = (((real8 ) valeur_numerique)) / pow(10, (double) exposant);
}	}
else	else
{	{
Line 4205 formateur_fichier_reel(struct_processus	Line 4349 formateur_fichier_reel(struct_processus

if (tampon_entier > ((integer8) 0))	if (tampon_entier > ((integer8) 0))
{	{
exposant = (long) floor(log10(tampon_entier));	exposant = (long) floor(log10((double) tampon_entier));
}	}
else if (tampon_entier < ((integer8) 0))	else if (tampon_entier < ((integer8) 0))
{	{
exposant = (long) floor(log10(-tampon_entier));	exposant = (long) floor(log10((double) -tampon_entier));
}	}
else	else
{	{
exposant = 0;	exposant = 0;
}	}

mantisse = (((integer8 ) valeur_numerique)) / pow(10, exposant);	mantisse = ((real8) (((integer8 ) valeur_numerique))) /
	pow(10, (double) exposant);
}	}

longueur_utile = longueur;	longueur_utile = (long) longueur;
longueur_utile_limite = 15;	longueur_utile_limite = 15;

if (longueur_utile > longueur_utile_limite)	if (longueur_utile > longueur_utile_limite)
Line 4280 formateur_fichier_reel(struct_processus	Line 4425 formateur_fichier_reel(struct_processus

sprintf(format, "%%.%luf", longueur_utile);	sprintf(format, "%%.%luf", longueur_utile);

sprintf(tampon, format, (mantisse * pow(10, exposant)));	sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
strcpy(chaine, tampon);	strcpy(chaine, tampon);
}	}
else if (strcmp(mode, "ENG") == 0)	else if (strcmp(mode, "ENG") == 0)
Line 4303 formateur_fichier_reel(struct_processus	Line 4448 formateur_fichier_reel(struct_processus
longueur_utile -= correction;	longueur_utile -= correction;
sprintf(format, "%%.%luf", longueur_utile);	sprintf(format, "%%.%luf", longueur_utile);

sprintf(tampon, format, (mantisse * pow(10, correction)));	sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
strcpy(chaine, tampon);	strcpy(chaine, tampon);
strcat(chaine, "E");	strcat(chaine, "E");
sprintf(tampon, "%ld", (exposant - correction));	sprintf(tampon, "%ld", (exposant - correction));
Line 4333 formateur_fichier_reel(struct_processus	Line 4478 formateur_fichier_reel(struct_processus

sprintf(tampon, format, ((real8 ) valeur_numerique));	sprintf(tampon, format, ((real8 ) valeur_numerique));

i = strlen(tampon) - 1;	i = (integer8) (strlen(tampon)) - 1;
while(tampon[i] == '0')	while(tampon[i] == '0')
{	{
tampon[i] = 0;	tampon[i] = 0;
Line 4342 formateur_fichier_reel(struct_processus	Line 4487 formateur_fichier_reel(struct_processus

if (ds_imposition_separateur_decimal == d_faux)	if (ds_imposition_separateur_decimal == d_faux)
{	{
i = strlen(tampon) - 1;	i = ((integer8) strlen(tampon)) - 1;
if (tampon[i] == '.')	if (tampon[i] == '.')
{	{
tampon[i] = 0;	tampon[i] = 0;
Line 4357 formateur_fichier_reel(struct_processus	Line 4502 formateur_fichier_reel(struct_processus
{	{
if (strlen(chaine) > (size_t) longueur_champ)	if (strlen(chaine) > (size_t) longueur_champ)
{	{
for(i = 0; i < (unsigned long) longueur_champ; i++)	for(i = 0; i < longueur_champ; i++)
{	{
chaine[i] = '*';	chaine[i] = '*';
}	}
Line 4379 formateur_fichier_reel(struct_processus	Line 4524 formateur_fichier_reel(struct_processus
unsigned char *	unsigned char *
formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,	formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
void *valeur_numerique, unsigned char type_entree,	void *valeur_numerique, unsigned char type_entree,
unsigned char type, long longueur, long *longueur_conversion)	unsigned char type, integer8 longueur, integer8 *longueur_conversion)
{	{
unsigned char *chaine;	unsigned char *chaine;

Line 4413 formateur_fichier_binaire_nombre(struct_	Line 4558 formateur_fichier_binaire_nombre(struct_
}	}

(*longueur_conversion) = 2;	(*longueur_conversion) = 2;
chaine[0] = 0x10;	chaine[0] = (unsigned char) 0x10;
chaine[1] = (((integer8 ) valeur_numerique)) & 0xFF;	chaine[1] = (unsigned char) ((((integer8 )
	valeur_numerique)) & 0xFF);
break;	break;
}	}

Line 4436 formateur_fichier_binaire_nombre(struct_	Line 4582 formateur_fichier_binaire_nombre(struct_
}	}

(*longueur_conversion) = 3;	(*longueur_conversion) = 3;
chaine[0] = 0x11;	chaine[0] = (unsigned char) 0x11;
chaine[1] = ((((integer8 ) valeur_numerique)) >> 8)	chaine[1] = ((unsigned char) ((((integer8 )
& 0xFF;	valeur_numerique)) >> 8) & 0xFF);
chaine[2] = (((integer8 ) valeur_numerique)) & 0xFF;	chaine[2] = (unsigned char) ((((integer8 )
	valeur_numerique)) & 0xFF);
break;	break;
}	}

Line 4461 formateur_fichier_binaire_nombre(struct_	Line 4608 formateur_fichier_binaire_nombre(struct_
}	}

(*longueur_conversion) = 5;	(*longueur_conversion) = 5;
chaine[0] = 0x12;	chaine[0] = (unsigned char) 0x12;
chaine[1] = ((((integer8 ) valeur_numerique)) >> 24)	chaine[1] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 24) & 0xFF);
chaine[2] = ((((integer8 ) valeur_numerique)) >> 16)	chaine[2] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 16) & 0xFF);
chaine[3] = ((((integer8 ) valeur_numerique)) >> 8)	chaine[3] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 8) & 0xFF);
chaine[4] = (((integer8 ) valeur_numerique)) & 0xFF;	chaine[4] = (unsigned char) ((((integer8 )
	valeur_numerique)) & 0xFF);
break;	break;
}	}

Line 4482 formateur_fichier_binaire_nombre(struct_	Line 4630 formateur_fichier_binaire_nombre(struct_
}	}

(*longueur_conversion) = 9;	(*longueur_conversion) = 9;
chaine[0] = 0x13;	chaine[0] = (unsigned char) 0x13;
chaine[1] = ((((integer8 ) valeur_numerique)) >> 56)	chaine[1] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 56) & 0xFF);
chaine[2] = ((((integer8 ) valeur_numerique)) >> 48)	chaine[2] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 48) & 0xFF);
chaine[3] = ((((integer8 ) valeur_numerique)) >> 40)	chaine[3] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 40) & 0xFF);
chaine[4] = ((((integer8 ) valeur_numerique)) >> 32)	chaine[4] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 32) & 0xFF);
chaine[5] = ((((integer8 ) valeur_numerique)) >> 24)	chaine[5] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 24) & 0xFF);
chaine[6] = ((((integer8 ) valeur_numerique)) >> 16)	chaine[6] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 16) & 0xFF);
chaine[7] = ((((integer8 ) valeur_numerique)) >> 8)	chaine[7] = (unsigned char) (((((integer8 )
& 0xFF;	valeur_numerique)) >> 8) & 0xFF);
chaine[8] = (((integer8 ) valeur_numerique)) & 0xFF;	chaine[8] = (unsigned char) ((((integer8 )
	valeur_numerique)) & 0xFF);
break;	break;
}	}

Line 4534 formateur_fichier_binaire_nombre(struct_	Line 4683 formateur_fichier_binaire_nombre(struct_
}	}
else if (type_entree == 'I')	else if (type_entree == 'I')
{	{
valeur = (((integer8 ) valeur_numerique));	valeur = (real8) (((integer8 ) valeur_numerique));
}	}
else	else
{	{
Line 4571 formateur_fichier_binaire_nombre(struct_	Line 4720 formateur_fichier_binaire_nombre(struct_

eq4.r4 = (real4) valeur;	eq4.r4 = (real4) valeur;
(*longueur_conversion) = 5;	(*longueur_conversion) = 5;
chaine[0] = 0x14;	chaine[0] = (unsigned char) 0x14;
chaine[1] = (eq4.i4 >> 24) & 0xFF;	chaine[1] = (unsigned char) ((eq4.i4 >> 24) & 0xFF);
chaine[2] = (eq4.i4 >> 16) & 0xFF;	chaine[2] = (unsigned char) ((eq4.i4 >> 16) & 0xFF);
chaine[3] = (eq4.i4 >> 8) & 0xFF;	chaine[3] = (unsigned char) ((eq4.i4 >> 8) & 0xFF);
chaine[4] = eq4.i4 & 0xFF;	chaine[4] = (unsigned char) (eq4.i4 & 0xFF);
break;	break;
}	}

Line 4596 formateur_fichier_binaire_nombre(struct_	Line 4745 formateur_fichier_binaire_nombre(struct_

if (type_entree == 'I')	if (type_entree == 'I')
{	{
eq8.r8 = (((integer8 ) valeur_numerique));	eq8.r8 = (real8) (((integer8 ) valeur_numerique));
}	}
else if (type_entree == 'R')	else if (type_entree == 'R')
{	{
Line 4610 formateur_fichier_binaire_nombre(struct_	Line 4759 formateur_fichier_binaire_nombre(struct_
}	}

(*longueur_conversion) = 9;	(*longueur_conversion) = 9;
chaine[0] = 0x15;	chaine[0] = (unsigned char) (0x15);
chaine[1] = (eq8.i8 >> 56) & 0xFF;	chaine[1] = (unsigned char) ((eq8.i8 >> 56) & 0xFF);
chaine[2] = (eq8.i8 >> 48) & 0xFF;	chaine[2] = (unsigned char) ((eq8.i8 >> 48) & 0xFF);
chaine[3] = (eq8.i8 >> 40) & 0xFF;	chaine[3] = (unsigned char) ((eq8.i8 >> 40) & 0xFF);
chaine[4] = (eq8.i8 >> 32) & 0xFF;	chaine[4] = (unsigned char) ((eq8.i8 >> 32) & 0xFF);
chaine[5] = (eq8.i8 >> 24) & 0xFF;	chaine[5] = (unsigned char) ((eq8.i8 >> 24) & 0xFF);
chaine[6] = (eq8.i8 >> 16) & 0xFF;	chaine[6] = (unsigned char) ((eq8.i8 >> 16) & 0xFF);
chaine[7] = (eq8.i8 >> 8) & 0xFF;	chaine[7] = (unsigned char) ((eq8.i8 >> 8) & 0xFF);
chaine[8] = eq8.i8 & 0xFF;	chaine[8] = (unsigned char) (eq8.i8 & 0xFF);
break;	break;
}	}

Line 4642 formateur_fichier_binaire_nombre(struct_	Line 4791 formateur_fichier_binaire_nombre(struct_
unsigned char *partie_reelle;	unsigned char *partie_reelle;
unsigned char *partie_imaginaire;	unsigned char *partie_imaginaire;

long limag;	integer8 limag;
long lreel;	integer8 lreel;

real8 zero;	real8 zero;

Line 4716 formateur_fichier_binaire_nombre(struct_	Line 4865 formateur_fichier_binaire_nombre(struct_
return(NULL);	return(NULL);
}	}

if ((chaine = malloc((lreel + limag - 1) *	if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
sizeof(unsigned char))) == NULL)	- 1) * sizeof(unsigned char))) == NULL)
{	{
free(partie_reelle);	free(partie_reelle);
free(partie_imaginaire);	free(partie_imaginaire);
Line 4727 formateur_fichier_binaire_nombre(struct_	Line 4876 formateur_fichier_binaire_nombre(struct_
return(NULL);	return(NULL);
}	}

chaine[0] = 0x18;	chaine[0] = (unsigned char) 0x18;
memcpy(chaine + 1, partie_reelle + 1, lreel - 1);	memcpy(chaine + 1, partie_reelle + 1,
memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);	((size_t) lreel) - 1);
	memcpy(chaine + lreel, partie_imaginaire + 1,
	((size_t) limag) - 1);
(*longueur_conversion) = lreel + limag - 1;	(*longueur_conversion) = lreel + limag - 1;

free(partie_reelle);	free(partie_reelle);
Line 4742 formateur_fichier_binaire_nombre(struct_	Line 4893 formateur_fichier_binaire_nombre(struct_
unsigned char *partie_reelle;	unsigned char *partie_reelle;
unsigned char *partie_imaginaire;	unsigned char *partie_imaginaire;

long limag;	integer8 limag;
long lreel;	integer8 lreel;

real8 zero;	real8 zero;

if (type_entree == 'I')	if (type_entree == 'I')
Line 4815 formateur_fichier_binaire_nombre(struct_	Line 4967 formateur_fichier_binaire_nombre(struct_
return(NULL);	return(NULL);
}	}

if ((chaine = malloc((lreel + limag - 1) *	if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
sizeof(unsigned char))) == NULL)	- 1) * sizeof(unsigned char))) == NULL)
{	{
free(partie_reelle);	free(partie_reelle);
free(partie_imaginaire);	free(partie_imaginaire);
Line 4826 formateur_fichier_binaire_nombre(struct_	Line 4978 formateur_fichier_binaire_nombre(struct_
return(NULL);	return(NULL);
}	}

chaine[0] = 0x19;	chaine[0] = (unsigned char) 0x19;
memcpy(chaine + 1, partie_reelle + 1, lreel - 1);	memcpy(chaine + 1, partie_reelle + 1,
memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);	((size_t) lreel) - 1);
	memcpy(chaine + lreel, partie_imaginaire + 1,
	((size_t) limag) - 1);
(*longueur_conversion) = lreel + limag - 1;	(*longueur_conversion) = lreel + limag - 1;

free(partie_reelle);	free(partie_reelle);
Line 4892 lecture_fichier_non_formate(struct_proce	Line 5046 lecture_fichier_non_formate(struct_proce
unsigned char *buffer;	unsigned char *buffer;
unsigned char *flux;	unsigned char *flux;
unsigned char *ptr;	unsigned char *ptr;
	unsigned char type_objet;

size_t deplacement;	size_t deplacement;

Line 4938 lecture_fichier_non_formate(struct_proce	Line 5093 lecture_fichier_non_formate(struct_proce
}	}
}	}

switch(octets[0] & 0xF0)	switch(type_objet = (octets[0] & 0xF0))
{	{
case 0x00: // Binaire	case 0x00: // Binaire
{	{
Line 5022 lecture_fichier_non_formate(struct_proce	Line 5177 lecture_fichier_non_formate(struct_proce
for(i = 0; i < (signed) deplacement; i++)	for(i = 0; i < (signed) deplacement; i++)
{	{
(((logical8 ) (*s_objet).objet)) \|= ((logical8) octets[i])	(((logical8 ) (*s_objet).objet)) \|= ((logical8) octets[i])
<< (8 * ((deplacement - 1) - i));	<< (8 * ((((signed) deplacement) - 1) - i));
}	}

break;	break;
Line 5102 lecture_fichier_non_formate(struct_proce	Line 5257 lecture_fichier_non_formate(struct_proce
return(NULL);	return(NULL);
}	}

(((integer8 ) (*s_objet).objet)) = 0;	// Récupération des données avec extension de signe.

for(i = 0; i < (signed) deplacement; i++)
{	{
(((integer8 ) (*s_objet).objet)) \|=	integer1 i1;
((integer8) octets[i])	integer2 i2;
<< (8 * ((deplacement - 1) - i));	integer4 i4;
	integer8 i8;

	i1 = 0;
	i2 = 0;
	i4 = 0;
	i8 = 0;

	for(i = 0; i < (signed) deplacement; i++)
	{
	switch(deplacement)
	{
	case 1:
	i1 = (integer1) octets[0];
	break;

	case 2:
	i2 \|= (integer2) (((integer8) octets[i]) <<
	(8 * ((((signed) deplacement) - 1)
	- i)));
	break;

	case 4:
	i4 \|= (integer4) (((integer8) octets[i]) <<
	(8 * ((((signed) deplacement) - 1)
	- i)));
	break;

	case 8:
	i8 \|= (integer8) (((integer8) octets[i]) <<
	(8 * ((((signed) deplacement) - 1)
	- i)));
	break;
	}
	}

	switch(deplacement)
	{
	case 1:
	(((integer8 ) (*s_objet).objet)) =
	(integer8) i1;
	break;

	case 2:
	(((integer8 ) (*s_objet).objet)) =
	(integer8) i2;
	break;

	case 4:
	(((integer8 ) (*s_objet).objet)) =
	(integer8) i4;
	break;

	case 8:
	(((integer8 ) (*s_objet).objet)) =
	(integer8) i8;
	break;
	}
}	}

break;	break;
Line 5193 lecture_fichier_non_formate(struct_proce	Line 5404 lecture_fichier_non_formate(struct_proce
for(i = 0; i < (signed) deplacement; i++)	for(i = 0; i < (signed) deplacement; i++)
{	{
eq4.i4 \|= ((integer4) octets[i]) <<	eq4.i4 \|= ((integer4) octets[i]) <<
(8 * ((deplacement - 1) - i));	(8 * ((((signed) deplacement) - 1) - i));
}	}

(((real8 ) (*s_objet).objet)) = (real8) eq4.r4;	(((real8 ) (*s_objet).objet)) = (real8) eq4.r4;
Line 5211 lecture_fichier_non_formate(struct_proce	Line 5422 lecture_fichier_non_formate(struct_proce
for(i = 0; i < (signed) deplacement; i++)	for(i = 0; i < (signed) deplacement; i++)
{	{
eq8.i8 \|= ((integer8) octets[i]) <<	eq8.i8 \|= ((integer8) octets[i]) <<
(8 * ((deplacement - 1) - i));	(8 * ((((signed) deplacement) - 1) - i));
}	}

(((real8 ) (*s_objet).objet)) = (real8) eq8.r8;	(((real8 ) (*s_objet).objet)) = (real8) eq8.r8;
Line 5304 lecture_fichier_non_formate(struct_proce	Line 5515 lecture_fichier_non_formate(struct_proce
for(i = 0; i < (signed) deplacement; i++)	for(i = 0; i < (signed) deplacement; i++)
{	{
eq4.i4 \|= ((integer4) octets[i]) <<	eq4.i4 \|= ((integer4) octets[i]) <<
(8 * ((deplacement - 1) - i));	(8 * ((((signed) deplacement) - 1)
	- i));
}	}

if (j == 0)	if (j == 0)
Line 5331 lecture_fichier_non_formate(struct_proce	Line 5543 lecture_fichier_non_formate(struct_proce
for(i = 0; i < (signed) deplacement; i++)	for(i = 0; i < (signed) deplacement; i++)
{	{
eq8.i8 \|= ((integer8) octets[i]) <<	eq8.i8 \|= ((integer8) octets[i]) <<
(8 * ((deplacement - 1) - i));	(8 * ((((signed) deplacement) - 1)
	- i));
}	}

if (j == 0)	if (j == 0)
Line 5361 lecture_fichier_non_formate(struct_proce	Line 5574 lecture_fichier_non_formate(struct_proce
}	}

case 0x40: // Liste	case 0x40: // Liste
	case 0x60: // Expression
	case 0x70: // Expression algébrique
{	{
if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits	if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
{	{
Line 5545 lecture_fichier_non_formate(struct_proce	Line 5760 lecture_fichier_non_formate(struct_proce
}	}
}	}

if ((s_objet = allocation(s_etat_processus, LST)) == NULL)	if (type_objet == 0x40)
{	{
return(NULL);	if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
	{
	return(NULL);
	}
	}
	else if (type_objet == 0x60)
	{
	if ((s_objet = allocation(s_etat_processus, RPN)) == NULL)
	{
	return(NULL);
	}
	}
	else
	{
	if ((s_objet = allocation(s_etat_processus, ALG)) == NULL)
	{
	return(NULL);
	}
}	}

l_element_courant = NULL;	l_element_courant = NULL;
Line 5796 lecture_fichier_non_formate(struct_proce	Line 6028 lecture_fichier_non_formate(struct_proce

if (longueur_buffer < 0)	if (longueur_buffer < 0)
{	{
if ((flux = malloc(longueur * sizeof(unsigned char))) == NULL)	if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 5804 lecture_fichier_non_formate(struct_proce	Line 6037 lecture_fichier_non_formate(struct_proce
}	}

if (fread(flux, (size_t) sizeof(unsigned char),	if (fread(flux, (size_t) sizeof(unsigned char),
longueur, fichier) != (size_t) longueur)	(size_t) longueur, fichier) != (size_t) longueur)
{	{
if (feof(fichier))	if (feof(fichier))
{	{
Line 5857 lecture_fichier_non_formate(struct_proce	Line 6090 lecture_fichier_non_formate(struct_proce
break;	break;
}	}

	case 0x50: // Nom
	{
	if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
	{
	longueur = (octets[0] & 0x07);
	}
	else
	{
	switch(octets[0] & 0x07)
	{
	case 0x00: // Longueur sur 8 bits
	{
	if (longueur_buffer < 0)
	{
	if (fread(octets, (size_t) sizeof(unsigned char),
	1, fichier) != 1)
	{
	if (feof(fichier))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	}

	return(NULL);
	}
	}
	else
	{
	if ((longueur_buffer - (ptr - buffer)) >= 1)
	{
	octets[0] = *ptr++;
	}
	else
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	return(NULL);
	}
	}

	longueur = octets[0];
	break;
	}

	case 0x01: // Longueur sur 16 bits
	{
	if (longueur_buffer < 0)
	{
	if (fread(octets, (size_t) sizeof(unsigned char),
	2, fichier) != 2)
	{
	if (feof(fichier))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	}

	return(NULL);
	}
	}
	else
	{
	if ((longueur_buffer - (ptr - buffer)) >= 2)
	{
	for(j = 0; j < 2; octets[j++] = *ptr++);
	}
	else
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	return(NULL);
	}
	}

	longueur = (((integer8) (octets[0])) << 8)
	\| ((integer8) (octets[1]));
	break;
	}

	case 0x02: // Longueur sur 32 bits
	{
	if (longueur_buffer < 0)
	{
	if (fread(octets, (size_t) sizeof(unsigned char),
	4, fichier) != 4)
	{
	if (feof(fichier))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	}

	return(NULL);
	}
	}
	else
	{
	if ((longueur_buffer - (ptr - buffer)) >= 4)
	{
	for(j = 0; j < 4; octets[j++] = *ptr++);
	}
	else
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	return(NULL);
	}
	}

	longueur = (((integer8) (octets[0])) << 24)
	\| (((integer8) (octets[1])) << 16)
	\| (((integer8) (octets[2])) << 8)
	\| ((integer8) (octets[3]));
	break;
	}

	case 0x03: // Longueur sur 64 bits
	{
	if (longueur_buffer < 0)
	{
	if (fread(octets, (size_t) sizeof(unsigned char),
	8, fichier) != 8)
	{
	if (feof(fichier))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	}

	return(NULL);
	}
	}
	else
	{
	if ((longueur_buffer - (ptr - buffer)) >= 8)
	{
	for(j = 0; j < 8; octets[j++] = *ptr++);
	}
	else
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	return(NULL);
	}
	}

	longueur = (((integer8) (octets[0])) << 56)
	\| (((integer8) (octets[1])) << 48)
	\| (((integer8) (octets[2])) << 40)
	\| (((integer8) (octets[3])) << 32)
	\| (((integer8) (octets[4])) << 24)
	\| (((integer8) (octets[5])) << 16)
	\| (((integer8) (octets[6])) << 8)
	\| ((integer8) (octets[7]));
	break;
	}

	default:
	{
	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	return(NULL);
	}
	}
	}

	if ((s_objet = allocation(s_etat_processus, NOM)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	if (((((struct_nom ) (*s_objet).objet)).nom =
	malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	if (longueur_buffer < 0)
	{
	if (fread((unsigned char ) (((struct_nom ) (s_objet)
	.objet)).nom, (size_t) sizeof(unsigned char),
	(size_t) longueur, fichier) != (unsigned) longueur)
	{
	if (feof(fichier))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	}

	liberation(s_etat_processus, s_objet);
	return(NULL);
	}

	if (fread(octets, (size_t) sizeof(unsigned char),
	1, fichier) != 1)
	{
	if (feof(fichier))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_syntaxe;
	}
	else
	{
	(*s_etat_processus).erreur_systeme =
	d_es_erreur_fichier;
	}

	liberation(s_etat_processus, s_objet);
	return(NULL);
	}
	}
	else
	{
	if ((longueur_buffer - (ptr - buffer)) >= (longueur + 1))
	{
	for(j = 0; j < longueur; (((struct_nom )
	(s_objet).objet)).nom[j] = ptr++);
	octets[0] = *ptr++;
	}
	else
	{
	liberation(s_etat_processus, s_objet);
	(*s_etat_processus).erreur_execution = d_ex_syntaxe;
	return(NULL);
	}
	}

	(((struct_nom ) (*s_objet).objet)).nom[longueur] =
	d_code_fin_chaine;
	(((struct_nom ) (*s_objet).objet)).symbole =
	(octets[0] == 0xFF) ? d_vrai : d_faux;
	break;
	}

case 0xE0: // Fonction	case 0xE0: // Fonction
{	{
if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits	if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits
Line 6049 lecture_fichier_non_formate(struct_proce	Line 6543 lecture_fichier_non_formate(struct_proce
}	}

if (((((struct_fonction ) (*s_objet).objet)).nom_fonction =	if (((((struct_fonction ) (*s_objet).objet)).nom_fonction =
malloc((longueur + 1) * sizeof(unsigned char))) == NULL)	malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 6059 lecture_fichier_non_formate(struct_proce	Line 6554 lecture_fichier_non_formate(struct_proce
{	{
if (fread((unsigned char ) (((struct_fonction ) (s_objet)	if (fread((unsigned char ) (((struct_fonction ) (s_objet)
.objet)).nom_fonction, (size_t) sizeof(unsigned char),	.objet)).nom_fonction, (size_t) sizeof(unsigned char),
longueur, fichier) != (unsigned) longueur)	(size_t) longueur, fichier) != (unsigned) longueur)
{	{
if (feof(fichier))	if (feof(fichier))
{	{
Line 6154 lecture_fichier_non_formate(struct_proce	Line 6649 lecture_fichier_non_formate(struct_proce

if ((octets[0] & 0x01) != 0)	if ((octets[0] & 0x01) != 0)
{	{
deplacement = ((octets[0] & 0x0F) >> 1) + 1;	deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1);

if (fread(octets, (size_t) sizeof(unsigned char), deplacement,	if (fread(octets, (size_t) sizeof(unsigned char), deplacement,
fichier) != deplacement)	fichier) != deplacement)

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.58
changed lines
	Added in v.1.66