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.60 and 1.74

version 1.60, 2013/03/19 12:46:32	version 1.74, 2013/09/06 10:30:51
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.16
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
Line 19	Line 19
================================================================================	================================================================================
*/	*/

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


Line 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;
struct_liste_chainee *l_liste1;	struct_liste_chainee *l_liste1;
struct_liste_chainee *l_liste2;	struct_liste_chainee *l_liste2;

	struct_objet *s_format_tmp;
struct_objet *s_sous_objet;	struct_objet *s_sous_objet;
struct_objet *s_sous_objet_1;	struct_objet *s_sous_objet_1;
struct_objet *s_sous_objet_2;	struct_objet *s_sous_objet_2;
Line 103 formateur_fichier(struct_processus *s_et	Line 103 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 929 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 1000 formateur_fichier(struct_processus *s_et	Line 1001 formateur_fichier(struct_processus *s_et

if (format_sortie == 'N')	if (format_sortie == 'N')
{	{
sprintf(tampon, "%llX", (((logical8 )	sprintf(tampon, "%llX", (unsigned long long) (((logical8 )
((*s_objet).objet))));	((*s_objet).objet))));
strcpy(base, "h");	strcpy(base, "h");
}	}
Line 1010 formateur_fichier(struct_processus *s_et	Line 1011 formateur_fichier(struct_processus *s_et
{	{
case 2:	case 2:
{	{
sprintf(tampon, "%llX", (((logical8 )	sprintf(tampon, "%llX", (unsigned long long)
((*s_objet).objet))));	(((logical8 ) ((*s_objet).objet))));

chaine = (unsigned char *) malloc((strlen(tampon) + 1)	chaine = (unsigned char *) malloc((strlen(tampon) + 1)
* sizeof(unsigned char));	* sizeof(unsigned char));
Line 1026 formateur_fichier(struct_processus *s_et	Line 1027 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 1120 formateur_fichier(struct_processus *s_et	Line 1121 formateur_fichier(struct_processus *s_et

case 8:	case 8:
{	{
sprintf(tampon, "%llo", (((logical8 )	sprintf(tampon, "%llo", (((unsigned long long )
((*s_objet).objet))));	((*s_objet).objet))));
strcpy(base, "o");	strcpy(base, "o");
break;	break;
Line 1128 formateur_fichier(struct_processus *s_et	Line 1129 formateur_fichier(struct_processus *s_et

case 10:	case 10:
{	{
sprintf(tampon, "%llu", (((logical8 )	sprintf(tampon, "%llu", (((unsigned long long )
((*s_objet).objet))));	((*s_objet).objet))));
strcpy(base, "d");	strcpy(base, "d");
break;	break;
Line 1136 formateur_fichier(struct_processus *s_et	Line 1137 formateur_fichier(struct_processus *s_et

case 16:	case 16:
{	{
sprintf(tampon, "%llX", (((logical8 )	sprintf(tampon, "%llX", (unsigned long long)
((*s_objet).objet))));	(((logical8 ) ((*s_objet).objet))));
strcpy(base, "h");	strcpy(base, "h");
break;	break;
}	}
Line 1156 formateur_fichier(struct_processus *s_et	Line 1157 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 1230 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 1239 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 1590 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 1625 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 1643 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 1672 formateur_fichier(struct_processus *s_et	Line 1674 formateur_fichier(struct_processus *s_et

chaine_sauvegarde = chaine;	chaine_sauvegarde = chaine;

	// Si le format_sortie vaut 'N', on remplace le format par
	// { "native()" }. L'intérêt est de pouvoir traiter une
	// liste par un format "native()".

	if ((format_sortie == 'N') && (((l_element_courant)
	.donnee).type == LST))
	{
	if ((s_format_tmp = allocation(s_etat_processus, LST))
	== NULL)
	{
	return(NULL);
	}

	if (((*s_format_tmp).objet = allocation_maillon(
	s_etat_processus)) == NULL)
	{
	return(NULL);
	}

	(((struct_liste_chainee ) (*s_format_tmp).objet))
	.suivant = NULL;

	if (((((struct_liste_chainee ) (*s_format_tmp).objet))
	.donnee = allocation(s_etat_processus, CHN))
	== NULL)
	{
	return(NULL);
	}

	if ((((((struct_liste_chainee ) (s_format_tmp)
	.objet)).donnee).objet = malloc(11 *
	sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	strcpy((unsigned char ) ((((struct_liste_chainee )
	(*s_format_tmp).objet)).donnee).objet,
	"native()");
	}
	else
	{
	if ((s_format_tmp = copie_objet(s_etat_processus,
	s_format, 'P')) == NULL)
	{
	return(NULL);
	}
	}

if ((chaine_formatee = formateur_fichier(s_etat_processus,	if ((chaine_formatee = formateur_fichier(s_etat_processus,
(*l_element_courant).donnee, s_format,	(*l_element_courant).donnee, s_format,
longueur, longueur_champ, format_sortie, type,	longueur, longueur_champ, format_sortie, type,
longueur_effective, recursivite, export_fichier))	longueur_effective, recursivite, export_fichier))
== NULL)	== NULL)
{	{
	liberation(s_etat_processus, s_format_tmp);
free(chaine);	free(chaine);
return(NULL);	return(NULL);
}	}

	liberation(s_etat_processus, s_format_tmp);

if (((l_element_courant).donnee).type == CHN)	if (((l_element_courant).donnee).type == CHN)
{	{
chaine = (unsigned char *)	chaine = (unsigned char *)
Line 1936 formateur_fichier(struct_processus *s_et	Line 1992 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 2016 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 2034 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 2930 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 3143 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 3208 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 3225 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 3233 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 3250 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 3267 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 3286 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 3295 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 3309 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 3326 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 3411 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 3424 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);
Line 3370 formateur_fichier(struct_processus *s_et	Line 3432 formateur_fichier(struct_processus *s_et
}	}
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 3378 formateur_fichier(struct_processus *s_et	Line 3440 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))
Line 3387 formateur_fichier(struct_processus *s_et	Line 3449 formateur_fichier(struct_processus *s_et
}	}
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 3395 formateur_fichier(struct_processus *s_et	Line 3457 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);

Line 3405 formateur_fichier(struct_processus *s_et	Line 3467 formateur_fichier(struct_processus *s_et
}	}
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 3413 formateur_fichier(struct_processus *s_et	Line 3475 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 3425 formateur_fichier(struct_processus *s_et	Line 3487 formateur_fichier(struct_processus *s_et
}	}
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 3433 formateur_fichier(struct_processus *s_et	Line 3495 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 3506 formateur_fichier(struct_processus *s_et	Line 3568 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 3535 formateur_fichier(struct_processus *s_et	Line 3598 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 3552 formateur_fichier(struct_processus *s_et	Line 3616 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 3571 formateur_fichier(struct_processus *s_et	Line 3636 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 3594 formateur_fichier(struct_processus *s_et	Line 3660 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 3666 formateur_fichier(struct_processus *s_et	Line 3733 formateur_fichier(struct_processus *s_et
}	}
}	}

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 3676 formateur_fichier(struct_processus *s_et	Line 3743 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 3753 formateur_fichier(struct_processus *s_et	Line 3820 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 3773 formateur_fichier(struct_processus *s_et	Line 3840 formateur_fichier(struct_processus *s_et
}	}

free(format_chaine);	free(format_chaine);

	// Si le format_sortie vaut 'N', on remplace le format par
	// { "native()" }. L'intérêt est de pouvoir traiter une
	// liste par un format "native()".

	if ((format_sortie == 'N') && (((l_element_courant)
	.donnee).type == LST))
	{
	if ((s_format_tmp = allocation(s_etat_processus, LST))
	== NULL)
	{
	return(NULL);
	}

	if (((*s_format_tmp).objet = allocation_maillon(
	s_etat_processus)) == NULL)
	{
	return(NULL);
	}

	(((struct_liste_chainee ) (*s_format_tmp).objet))
	.suivant = NULL;

	if (((((struct_liste_chainee ) (*s_format_tmp).objet))
	.donnee = allocation(s_etat_processus, CHN))
	== NULL)
	{
	return(NULL);
	}

	if ((((((struct_liste_chainee ) (s_format_tmp)
	.objet)).donnee).objet = malloc(11 *
	sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	strcpy((unsigned char ) ((((struct_liste_chainee )
	(*s_format_tmp).objet)).donnee).objet,
	"native()");
	}
	else
	{
	if ((s_format_tmp = copie_objet(s_etat_processus,
	s_format, 'P')) == NULL)
	{
	return(NULL);
	}
	}

if ((chaine_formatee = formateur_fichier(s_etat_processus,	if ((chaine_formatee = formateur_fichier(s_etat_processus,
(*l_element_courant).donnee, s_format,	(*l_element_courant).donnee, s_format_tmp,
longueur, longueur_champ, format_sortie, type,	longueur, longueur_champ, format_sortie, type,
longueur_effective, recursivite, export_fichier))	longueur_effective, recursivite, export_fichier))
== NULL)	== NULL)
{	{
	liberation(s_etat_processus, s_format_tmp);
free(chaine);	free(chaine);
return(NULL);	return(NULL);
}	}

	liberation(s_etat_processus, s_format_tmp);

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 3794 formateur_fichier(struct_processus *s_et	Line 3915 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++;
l_element_courant = (*l_element_courant).suivant;

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

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

if (format_sortie != 'N')	if (format_sortie != 'N')
Line 3876 formateur_fichier(struct_processus *s_et	Line 3997 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

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

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

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

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

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

strcpy(chaine + 2, (((struct_nom ) (*s_objet).objet)).nom);	strcpy(chaine + 2, (((struct_nom ) (*s_objet).objet)).nom);
Line 3912 formateur_fichier(struct_processus *s_et	Line 4033 formateur_fichier(struct_processus *s_et
}	}
else if (longueur_fonction < (1LL << 16))	else if (longueur_fonction < (1LL << 16))
{	{
if ((chaine = malloc((3 + longueur_fonction + 1)	if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3920 formateur_fichier(struct_processus *s_et	Line 4041 formateur_fichier(struct_processus *s_et
return(NULL);	return(NULL);
}	}

chaine[0] = 0x50 \| 0x09;	chaine[0] = (unsigned char) (0x50 \| 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);

Line 3929 formateur_fichier(struct_processus *s_et	Line 4050 formateur_fichier(struct_processus *s_et
}	}
else if (longueur_fonction < (1LL << 32))	else if (longueur_fonction < (1LL << 32))
{	{
if ((chaine = malloc((5 + longueur_fonction + 1)	if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3937 formateur_fichier(struct_processus *s_et	Line 4058 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 3948 formateur_fichier(struct_processus *s_et	Line 4069 formateur_fichier(struct_processus *s_et
}	}
else	else
{	{
if ((chaine = malloc((9 + longueur_fonction + 1)	if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1)
* sizeof(unsigned char)))== NULL)	* sizeof(unsigned char)))== NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 3956 formateur_fichier(struct_processus *s_et	Line 4077 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 4051 formateur_fichier(struct_processus *s_et	Line 4172 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 4065 formateur_fichier(struct_processus *s_et	Line 4187 formateur_fichier(struct_processus *s_et
memcpy(&(chaine[longueur_totale]), tampon, 1);	memcpy(&(chaine[longueur_totale]), tampon, 1);
longueur_totale += 1;	longueur_totale += 1;
}	}
else if (longueur_totale < (((integer8) 1) << 16))	else
{	{
longueur_totale++;	longueur_totale++;

for(i = 0; i < 7; i++)	// i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) }

	i = 0;

	for(;;)
{	{
if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))	if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
\|\| (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;
}	}

	switch(i)
	{
	case 0 :
	{
	i = 2;
	break;
	}

	case 2 :
	{
	i = 6;
	break;
	}
	}
}	}

if ((chaine = realloc(chaine, (longueur_totale + 3)	// i = 0 => +3 (16 bits)
	// i = 2 => +5 (32 bits)
	// i = 6 => +9 (64 bits)

	if ((chaine = realloc(chaine, (((size_t) longueur_totale)
	+ ((i == 0) ? 3 : ((i == 2) ? 5 : 9)))
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 4105 formateur_fichier(struct_processus *s_et	Line 4252 formateur_fichier(struct_processus *s_et
memcpy(&(chaine[longueur_totale]), tampon, 3);	memcpy(&(chaine[longueur_totale]), tampon, 3);
longueur_totale += 3;	longueur_totale += 3;
}	}
else if (longueur_totale < (((integer8) 1) << 32))
{
}

__zone();	__zone();
(*longueur_effective) = longueur_totale;	(*longueur_effective) = longueur_totale;
Line 4143 formateur_fichier(struct_processus *s_et	Line 4287 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 4283 formateur_fichier_nombre(struct_processu	Line 4427 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 4301 formateur_fichier_reel(struct_processus	Line 4446 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 4328 formateur_fichier_reel(struct_processus	Line 4471 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 4336 formateur_fichier_reel(struct_processus	Line 4479 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 4411 formateur_fichier_reel(struct_processus	Line 4555 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 4434 formateur_fichier_reel(struct_processus	Line 4578 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 4464 formateur_fichier_reel(struct_processus	Line 4608 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 4473 formateur_fichier_reel(struct_processus	Line 4617 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 4488 formateur_fichier_reel(struct_processus	Line 4632 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 4510 formateur_fichier_reel(struct_processus	Line 4654 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 4544 formateur_fichier_binaire_nombre(struct_	Line 4688 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 4567 formateur_fichier_binaire_nombre(struct_	Line 4712 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 4592 formateur_fichier_binaire_nombre(struct_	Line 4738 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 4613 formateur_fichier_binaire_nombre(struct_	Line 4760 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 4665 formateur_fichier_binaire_nombre(struct_	Line 4813 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 4702 formateur_fichier_binaire_nombre(struct_	Line 4850 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 4727 formateur_fichier_binaire_nombre(struct_	Line 4875 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 4741 formateur_fichier_binaire_nombre(struct_	Line 4889 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 4773 formateur_fichier_binaire_nombre(struct_	Line 4921 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 4847 formateur_fichier_binaire_nombre(struct_	Line 4995 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 4858 formateur_fichier_binaire_nombre(struct_	Line 5006 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 4873 formateur_fichier_binaire_nombre(struct_	Line 5023 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 4946 formateur_fichier_binaire_nombre(struct_	Line 5097 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 4957 formateur_fichier_binaire_nombre(struct_	Line 5108 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 5154 lecture_fichier_non_formate(struct_proce	Line 5307 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 5234 lecture_fichier_non_formate(struct_proce	Line 5387 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 5325 lecture_fichier_non_formate(struct_proce	Line 5534 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 5343 lecture_fichier_non_formate(struct_proce	Line 5552 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 5436 lecture_fichier_non_formate(struct_proce	Line 5645 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 5463 lecture_fichier_non_formate(struct_proce	Line 5673 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 5947 lecture_fichier_non_formate(struct_proce	Line 6158 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 5955 lecture_fichier_non_formate(struct_proce	Line 6167 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 6200 lecture_fichier_non_formate(struct_proce	Line 6412 lecture_fichier_non_formate(struct_proce
}	}

if (((((struct_nom ) (*s_objet).objet)).nom =	if (((((struct_nom ) (*s_objet).objet)).nom =
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 6210 lecture_fichier_non_formate(struct_proce	Line 6423 lecture_fichier_non_formate(struct_proce
{	{
if (fread((unsigned char ) (((struct_nom ) (s_objet)	if (fread((unsigned char ) (((struct_nom ) (s_objet)
.objet)).nom, (size_t) sizeof(unsigned char),	.objet)).nom, (size_t) sizeof(unsigned char),
longueur, fichier) != (unsigned) longueur)	(size_t) longueur, fichier) != (unsigned) longueur)
{	{
if (feof(fichier))	if (feof(fichier))
{	{
Line 6460 lecture_fichier_non_formate(struct_proce	Line 6673 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 6470 lecture_fichier_non_formate(struct_proce	Line 6684 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 6565 lecture_fichier_non_formate(struct_proce	Line 6779 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.60
changed lines
	Added in v.1.74