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.84

version 1.60, 2013/03/19 12:46:32	version 1.84, 2015/03/26 11:10:46
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.21
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2015 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 95 formateur_fichier(struct_processus *s_et	Line 95 formateur_fichier(struct_processus *s_et
unsigned char *chaine;	unsigned char *chaine;
unsigned char *chaine_fonction;	unsigned char *chaine_fonction;
unsigned char *chaine_formatee;	unsigned char *chaine_formatee;
	unsigned char *chaine_offset;
unsigned char *chaine_tampon;	unsigned char *chaine_tampon;
unsigned char *chaine_sauvegarde;	unsigned char *chaine_sauvegarde;
unsigned char *format_chaine;	unsigned char *format_chaine;
Line 103 formateur_fichier(struct_processus *s_et	Line 104 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_element;
integer8 longueur_fonction;	integer8 longueur_fonction;
integer8 longueur_liste;	integer8 longueur_liste;
	integer8 longueur_objet;
integer8 longueur_reelle_chaine;	integer8 longueur_reelle_chaine;
integer8 longueur_totale;	integer8 longueur_totale;
integer8 position_1;	integer8 position_1;
Line 233 formateur_fichier(struct_processus *s_et	Line 237 formateur_fichier(struct_processus *s_et
.instruction_courante[1]	.instruction_courante[1]
== '-')) ? d_vrai : d_faux;	== '-')) ? d_vrai : d_faux;

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

if ((*s_etat_processus).erreur_execution != d_ex)	if ((*s_etat_processus).erreur_execution != d_ex)
Line 292 formateur_fichier(struct_processus *s_et	Line 297 formateur_fichier(struct_processus *s_et
if ((strcmp(chaine_fonction, "AND") == 0) \|\|	if ((strcmp(chaine_fonction, "AND") == 0) \|\|
(strcmp(chaine_fonction, "XOR") ==	(strcmp(chaine_fonction, "XOR") ==
0) \|\| (strcmp(chaine_fonction, "OR")	0) \|\| (strcmp(chaine_fonction, "OR")
== 0))	== 0) \|\| (strcmp(chaine_fonction,
	"EQV") == 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
}	}
Line 319 formateur_fichier(struct_processus *s_et	Line 325 formateur_fichier(struct_processus *s_et
\|\| (strcmp(chaine_fonction, "AND")	\|\| (strcmp(chaine_fonction, "AND")
== 0) \|\| (strcmp(chaine_fonction,	== 0) \|\| (strcmp(chaine_fonction,
"XOR") == 0) \|\| (strcmp(	"XOR") == 0) \|\| (strcmp(
chaine_fonction, "OR") == 0))	chaine_fonction, "OR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV")
	== 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
}	}
Line 400 formateur_fichier(struct_processus *s_et	Line 408 formateur_fichier(struct_processus *s_et
"'%s'", (unsigned char *)	"'%s'", (unsigned char *)
(*s_sous_objet_1).objet);	(*s_sous_objet_1).objet);

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

if ((*s_etat_processus).erreur_execution != d_ex)	if ((*s_etat_processus).erreur_execution != d_ex)
Line 457 formateur_fichier(struct_processus *s_et	Line 466 formateur_fichier(struct_processus *s_et
if ((strcmp(chaine_fonction, "AND") == 0) \|\|	if ((strcmp(chaine_fonction, "AND") == 0) \|\|
(strcmp(chaine_fonction, "XOR") ==	(strcmp(chaine_fonction, "XOR") ==
0) \|\| (strcmp(chaine_fonction, "OR")	0) \|\| (strcmp(chaine_fonction, "OR")
== 0))	== 0) \|\| (strcmp(chaine_fonction,
	"EQV") == 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
}	}
Line 474 formateur_fichier(struct_processus *s_et	Line 484 formateur_fichier(struct_processus *s_et
\|\| (strcmp(chaine_fonction, "AND")	\|\| (strcmp(chaine_fonction, "AND")
== 0) \|\| (strcmp(chaine_fonction,	== 0) \|\| (strcmp(chaine_fonction,
"XOR") == 0) \|\| (strcmp(	"XOR") == 0) \|\| (strcmp(
chaine_fonction, "OR") == 0))	chaine_fonction, "OR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV")
	== 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
}	}
Line 715 formateur_fichier(struct_processus *s_et	Line 727 formateur_fichier(struct_processus *s_et
"XOR") == 0) \|\| (strcmp((((struct_fonction )	"XOR") == 0) \|\| (strcmp((((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.nom_fonction,	.nom_fonction,
"AND") == 0))	"AND") == 0) \|\| (strcmp((((struct_fonction )
	((l_element_courant).donnee).objet))
	.nom_fonction, "EQV") == 0))
{	{
if (depilement(s_etat_processus,	if (depilement(s_etat_processus,
&((*s_etat_processus)	&((*s_etat_processus)
Line 928 formateur_fichier(struct_processus *s_et	Line 942 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 1014 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 1024 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 1040 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 1134 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 1142 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 1150 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 1170 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 1243 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 1252 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 1529 formateur_fichier(struct_processus *s_et	Line 1544 formateur_fichier(struct_processus *s_et
}	}
else	else
{	{
if ((format_chaine = conversion_majuscule((unsigned char *)	if ((format_chaine = conversion_majuscule(
	s_etat_processus, (unsigned char *)
((l_element_courant_format).donnee).objet))	((l_element_courant_format).donnee).objet))
== NULL)	== NULL)
{	{
Line 1588 formateur_fichier(struct_processus *s_et	Line 1604 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 1639 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 1657 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 1688 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 1877 formateur_fichier(struct_processus *s_et	Line 1947 formateur_fichier(struct_processus *s_et
else	else
{	{
if ((format_chaine = conversion_majuscule(	if ((format_chaine = conversion_majuscule(
	s_etat_processus,
(unsigned char ) ((((struct_tableau )	(unsigned char ) ((((struct_tableau )
(*s_format).objet)).elements[i]).objet))	(*s_format).objet)).elements[i]).objet))
== NULL)	== NULL)
Line 1936 formateur_fichier(struct_processus *s_et	Line 2007 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 2031 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 2049 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 2945 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 3158 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 3223 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 3240 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 3248 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 3265 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 3282 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 3301 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 3310 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 3324 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 3341 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 3426 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 3439 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 3447 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 3455 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 3464 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 3472 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 3482 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 3490 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 3502 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 3510 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 3583 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 3613 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 3631 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 3651 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 3675 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 3748 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 3758 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 3690 formateur_fichier(struct_processus *s_et	Line 3772 formateur_fichier(struct_processus *s_et
}	}
else	else
{	{
if ((format_chaine = conversion_majuscule((unsigned char *)	if ((format_chaine = conversion_majuscule(
	s_etat_processus, (unsigned char *)
((l_element_courant_format).donnee).objet))	((l_element_courant_format).donnee).objet))
== NULL)	== NULL)
{	{
Line 3753 formateur_fichier(struct_processus *s_et	Line 3836 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 3856 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 3931 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 4013 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 4026 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 4041 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 4049 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 4057 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 4066 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 4074 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 4085 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 4093 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 4011 formateur_fichier(struct_processus *s_et	Line 4148 formateur_fichier(struct_processus *s_et
Vecteur complexe	Vecteur complexe
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

	if (format_sortie == 'N')
	{
	format_sortie = 'C';
	longueur = 16;
	}

	if (format_sortie != 'C')
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_format_fichier;
	return(NULL);
	}

	longueur_objet = (((struct_vecteur ) (*s_objet).objet)).taille;

	if (longueur_objet < (1LL << 8))
	{
	// Taille sur un octet
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(2 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xB2;
	chaine[1] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 2;
	}
	else if (longueur_objet < (1LL << 16))
	{
	// Taille sur deux octets
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(3 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xB6;
	chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[2] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 3;
	}
	else if (longueur_objet < (1LL << 32))
	{
	// Taille sur quatre octets
	if ((chaine = malloc((size_t) (((*longueur_effective) =
	5 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xBA;
	chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[4] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 5;
	}
	else
	{
	// Taille sur huit octets
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(9 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xBE;
	chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
	chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
	chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
	chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
	chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[8] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 9;
	}

	switch(longueur)
	{
	case 8:
	{
	break;
	}

	default:
	case 16:
	{
	chaine[0] \|= 0x01;
	break;
	}
	}

	for(i = 0; i < longueur_objet; i++)
	{
	if ((chaine_tampon = formateur_fichier_binaire_nombre(
	s_etat_processus, &(((complex16 ) (((struct_vecteur *)
	(*s_objet).objet)).tableau)[i]), 'C', format_sortie,
	longueur, &longueur_element)) == NULL)
	{
	free(chaine);
	return(NULL);
	}

	memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
	(size_t) longueur);
	}
}	}
else if ((*s_objet).type == VIN)	else if ((*s_objet).type == VIN)
{	{
Line 4020 formateur_fichier(struct_processus *s_et	Line 4278 formateur_fichier(struct_processus *s_et
Vecteur entier	Vecteur entier
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

	if (format_sortie == 'N')
	{
	format_sortie = 'I';
	longueur = 8;
	}

	if ((format_sortie != 'I') && (format_sortie != 'R')
	&& (format_sortie != 'C'))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_format_fichier;
	return(NULL);
	}

	longueur_objet = (((struct_vecteur ) (*s_objet).objet)).taille;

	if (longueur_objet < (1LL << 8))
	{
	// Taille sur un octet
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(2 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0x20;
	chaine[1] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 2;
	}
	else if (longueur_objet < (1LL << 16))
	{
	// Taille sur deux octets
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(3 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0x24;
	chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[2] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 3;
	}
	else if (longueur_objet < (1LL << 32))
	{
	// Taille sur quatre octets
	if ((chaine = malloc((size_t) (((*longueur_effective) =
	5 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0x28;
	chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[4] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 5;
	}
	else
	{
	// Taille sur huit octets
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(9 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0x2C;
	chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
	chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
	chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
	chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
	chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[8] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 9;
	}

	switch(format_sortie)
	{
	default:
	case 'I':
	{
	break;
	}

	case 'R':
	{
	chaine[0] \|= 0x80;
	break;
	}

	case 'C':
	{
	chaine[0] \|= 0x90;
	break;
	}
	}

	switch(longueur)
	{
	case 1:
	{
	break;
	}

	case 2:
	{
	chaine[0] \|= 0x01;
	break;
	}

	case 4:
	{
	chaine[0] \|= 0x02;
	break;
	}

	default:
	case 8:
	{
	chaine[0] \|= 0x03;
	break;
	}
	}

	for(i = 0; i < longueur_objet; i++)
	{
	if ((chaine_tampon = formateur_fichier_binaire_nombre(
	s_etat_processus, &(((integer8 ) (((struct_vecteur *)
	(*s_objet).objet)).tableau)[i]), 'I', format_sortie,
	longueur, &longueur_element)) == NULL)
	{
	free(chaine);
	return(NULL);
	}

	memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
	(size_t) longueur);
	}
}	}
else if ((*s_objet).type == VRL)	else if ((*s_objet).type == VRL)
{	{
Line 4029 formateur_fichier(struct_processus *s_et	Line 4442 formateur_fichier(struct_processus *s_et
Vecteur réel	Vecteur réel
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

	if (format_sortie == 'N')
	{
	format_sortie = 'R';
	longueur = 8;
	}

	if ((format_sortie != 'R') && (format_sortie != 'C'))
	{
	(*s_etat_processus).erreur_execution =
	d_ex_erreur_format_fichier;
	return(NULL);
	}

	longueur_objet = (((struct_vecteur ) (*s_objet).objet)).taille;

	if (longueur_objet < (1LL << 8))
	{
	// Taille sur un octet
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(2 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xA2;
	chaine[1] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 2;
	}
	else if (longueur_objet < (1LL << 16))
	{
	// Taille sur deux octets
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(3 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xA6;
	chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[2] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 3;
	}
	else if (longueur_objet < (1LL << 32))
	{
	// Taille sur quatre octets
	if ((chaine = malloc((size_t) (((*longueur_effective) =
	5 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xAA;
	chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[4] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 5;
	}
	else
	{
	// Taille sur huit octets
	if ((chaine = malloc((size_t) ((*longueur_effective) =
	(9 + (longueur_objet * longueur)))
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	chaine[0] = 0xAE;
	chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
	chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
	chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
	chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
	chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
	chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
	chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
	chaine[8] = (unsigned char) (longueur_objet & 0xFF);
	chaine_offset = chaine + 9;
	}

	switch(format_sortie)
	{
	default:
	case 'R':
	{
	break;
	}

	case 'C':
	{
	chaine[0] \|= 0x10;
	break;
	}
	}

	switch(longueur)
	{
	case 4:
	{
	break;
	}

	default:
	case 8:
	{
	chaine[0] \|= 0x01;
	break;
	}
	}

	for(i = 0; i < longueur_objet; i++)
	{
	if ((chaine_tampon = formateur_fichier_binaire_nombre(
	s_etat_processus, &(((real8 ) (((struct_vecteur *)
	(*s_objet).objet)).tableau)[i]), 'R', format_sortie,
	longueur, &longueur_element)) == NULL)
	{
	free(chaine);
	return(NULL);
	}

	memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
	(size_t) longueur);
	}
}	}
else	else
{	{
Line 4051 formateur_fichier(struct_processus *s_et	Line 4600 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 4615 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 4680 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 4715 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 4855 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 4874 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 4899 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 4907 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 4983 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 5006 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 5036 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 5045 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 5060 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 5082 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 5116 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 5140 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 5166 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 5188 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 5241 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 4679 formateur_fichier_binaire_nombre(struct_	Line 5255 formateur_fichier_binaire_nombre(struct_
vinf = nextafter(valeur, 0);	vinf = nextafter(valeur, 0);
vsup = nextafter(valeur, valeur * 2);	vsup = nextafter(valeur, valeur * 2);
}	}
else	else if (valeur < 0)
{	{
vinf = nextafter(valeur, valeur * 2);	vinf = nextafter(valeur, valeur * 2);
vsup = nextafter(valeur, 0);	vsup = nextafter(valeur, 0);
}	}
	else
	{
	vinf = valeur;
	vsup = valeur;
	}

if (!((vinf <= ((real4) valeur)) &&	if (!((((real4) vinf) <= ((real4) valeur)) &&
(((real4) valeur) <= vsup)))	(((real4) valeur) <= ((real4) vsup))))
{	{
(*s_etat_processus).erreur_execution =	(*s_etat_processus).erreur_execution =
d_ex_representation;	d_ex_representation;
Line 4702 formateur_fichier_binaire_nombre(struct_	Line 5283 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 5308 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 5322 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 5354 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 5428 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 5439 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 5456 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 5530 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 5541 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 5740 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 5820 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 5967 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 5985 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 6078 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 6106 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 6591 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 6600 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 6845 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 6856 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 7106 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 7117 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 7212 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.84