rpl/src/formateur.c - diff

Return to formateur.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/formateur.c between versions 1.1 and 1.69

version 1.1, 2010/01/26 15:22:44	version 1.69, 2014/05/17 15:35:50
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.9	RPL/2 (R) version 4.1.18
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2014 Dr. BERTRAND Joël

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

Line 20	Line 20
*/	*/


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


/*	/*
Line 47 formateur(struct_processus *s_etat_proce	Line 47 formateur(struct_processus *s_etat_proce
logical4 autorisation_parenthese;	logical4 autorisation_parenthese;
logical4 presence_signe;	logical4 presence_signe;

	logical8 masque_binaire;

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_liste1;	struct_liste_chainee *l_liste1;
Line 70 formateur(struct_processus *s_etat_proce	Line 72 formateur(struct_processus *s_etat_proce
unsigned char *registre;	unsigned char *registre;
unsigned char tampon[1024 + 1];	unsigned char tampon[1024 + 1];

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;
unsigned long k;	integer8 k;
unsigned long longueur_binaire;	integer8 longueur_chaine;
unsigned long longueur_courante;	integer8 longueur_courante;
unsigned long longueur_decimale_courante;	integer8 longueur_decimale_courante;
unsigned long *longueurs_maximales;	integer8 *longueurs_maximales;
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;
unsigned long offset;	integer8 offset;

integer8 masque_binaire;

chaine = NULL;	chaine = NULL;
chaine_formatee = NULL;	chaine_formatee = NULL;
Line 92 formateur(struct_processus *s_etat_proce	Line 92 formateur(struct_processus *s_etat_proce

strcpy(base, " ");	strcpy(base, " ");

longueur_binaire = 0;
masque_binaire = 0;	masque_binaire = 0;

if ((*s_objet).type == ADR)	if ((*s_objet).type == ADR)
Line 104 formateur(struct_processus *s_etat_proce	Line 103 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

sprintf(tampon, "%016lX", (((unsigned long ) ((*s_objet).objet))));	if (alsprintf(&chaine, "@ %016llX", (((unsigned long long )
	((*s_objet).objet)))) < 0)
chaine = (unsigned char *) malloc((strlen(tampon) + 3)
* sizeof(unsigned char));

if (chaine == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

strcpy(chaine, "@ ");
strcat(chaine, tampon);
}	}
else if ((*s_objet).type == SLB)	else if ((*s_objet).type == SLB)
{	{
Line 127 formateur(struct_processus *s_etat_proce	Line 119 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

sprintf(tampon, " %016lX", (unsigned long) (((struct_bibliotheque )	# pragma GCC diagnostic push
(*s_objet).objet)).descripteur);	# pragma GCC diagnostic ignored "-Wpointer-to-int-cast"

chaine = (unsigned char *) malloc((strlen(tampon) + 10)	if (alsprintf(&chaine, "Library $ %016llX [%s]",
* sizeof(unsigned char));	(unsigned long long) (((struct_bibliotheque )
	(s_objet).objet)).descripteur, (((struct_bibliotheque *)
if (chaine == NULL)	(*s_objet).objet)).nom) < 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

strcpy(chaine, "Library $");	# pragma GCC diagnostic pop
strcat(chaine, tampon);

registre = chaine;

if ((chaine = malloc((strlen(registre) + 2 +
strlen(((struct_bibliotheque ) ((*s_objet).objet)).nom)
+ 2) * sizeof(unsigned char))) == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

sprintf(chaine, "%s [%s]", registre, (((struct_bibliotheque )
(*s_objet).objet)).nom);
free(registre);
}	}
else if ((*s_objet).type == SPH)	else if ((*s_objet).type == SPH)
{	{
Line 165 formateur(struct_processus *s_etat_proce	Line 143 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

sprintf(tampon, "%016lX", (unsigned long)	# pragma GCC diagnostic push
&((((struct_semaphore ) (*s_objet).objet)).semaphore));	# pragma GCC diagnostic ignored "-Wpointer-to-int-cast"

chaine = (unsigned char *) malloc((strlen(tampon) + 15 +
strlen((((struct_semaphore ) (*s_objet).objet)).nom))
* sizeof(unsigned char));

if (chaine == NULL)	if (alsprintf(&chaine, "Semaphore $ %016llX '%s'", (unsigned long long)
	&((((struct_semaphore ) (*s_objet).objet)).semaphore),
	(((struct_semaphore ) (*s_objet).objet)).nom) < 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

sprintf(chaine, "Semaphore $%s '%s'", tampon,	# pragma GCC diagnostic pop
(((struct_semaphore ) (*s_objet).objet)).nom);
}	}
else if ((*s_objet).type == SQL)	else if ((*s_objet).type == SQL)
{	{
Line 194 formateur(struct_processus *s_etat_proce	Line 170 formateur(struct_processus *s_etat_proce
"MYSQL") == 0)	"MYSQL") == 0)
{	{
# ifdef MYSQL_SUPPORT	# ifdef MYSQL_SUPPORT
sprintf(tampon, "Sql $%016lX (%s)",	if (alsprintf(&chaine, "Sql $ %016llX (%s)",
(long unsigned int) (((struct_connecteur_sql )	(unsigned long long) (((struct_connecteur_sql )
(*s_objet).objet)).descripteur.mysql,	(*s_objet).objet)).descripteur.mysql,
(((struct_connecteur_sql ) (*s_objet).objet)).type);	(((struct_connecteur_sql ) (*s_objet).objet)).type) < 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}
# else	# else
if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 217 formateur(struct_processus *s_etat_proce	Line 197 formateur(struct_processus *s_etat_proce
"POSTGRESQL") == 0)	"POSTGRESQL") == 0)
{	{
# ifdef POSTGRESQL_SUPPORT	# ifdef POSTGRESQL_SUPPORT
sprintf(tampon, "Sql $%016lX [ %s ]",	if (alsprintf(&chaine, "Sql $ %016llX (%s)",
(long unsigned int) (((struct_connecteur_sql )	(unsigned long long) (((struct_connecteur_sql )
(*s_objet).objet)).descripteur.postgresql,	(*s_objet).objet)).descripteur.postgresql,
(((struct_connecteur_sql ) (*s_objet).objet)).type);	(((struct_connecteur_sql ) (*s_objet).objet)).type) < 0)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}
# else	# else
if ((*s_etat_processus).langue == 'F')	if ((*s_etat_processus).langue == 'F')
{	{
Line 242 formateur(struct_processus *s_etat_proce	Line 226 formateur(struct_processus *s_etat_proce
(((struct_connecteur_sql ) (*s_objet).objet))	(((struct_connecteur_sql ) (*s_objet).objet))
.type));	.type));
}	}

chaine = (unsigned char *) malloc((strlen(tampon) + 1)
* sizeof(unsigned char));

if (chaine == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

strcpy(chaine, tampon);
}	}
else if ((*s_objet).type == PRC)	else if ((*s_objet).type == PRC)
{	{
Line 266 formateur(struct_processus *s_etat_proce	Line 239 formateur(struct_processus *s_etat_proce
if (((((struct_processus_fils ) (s_objet).objet)).thread)	if (((((struct_processus_fils ) (s_objet).objet)).thread)
.processus_detache == d_vrai)	.processus_detache == d_vrai)
{	{
sprintf(tampon, " %016lX", (unsigned long)	if (alsprintf(&chaine, "Process $ %016llX", (unsigned long long)
((((struct_processus_fils ) (s_objet).objet)).thread)	((((struct_processus_fils ) (s_objet).objet)).thread)
.pid);	.pid) < 0)

chaine = (unsigned char *) malloc((strlen(tampon) + 10)
* sizeof(unsigned char));

if (chaine == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

strcpy(chaine, "Process $");
strcat(chaine, tampon);
}	}
else	else
{	{
sprintf(tampon, " %016lX/%016lX",	if (alsprintf(&chaine, "Light weight process $ %016llX/%016llX",
(unsigned long) ((((struct_processus_fils *)	(unsigned long long) ((((struct_processus_fils *)
(*s_objet).objet)).thread).pid,	(*s_objet).objet)).thread).pid,
(unsigned long) ((((struct_processus_fils *)	(unsigned long long) ((((struct_processus_fils *)
(*s_objet).objet)).thread).tid);	(*s_objet).objet)).thread).tid) < 0)

chaine = (unsigned char *) malloc((strlen(tampon) + 23)
* sizeof(unsigned char));

if (chaine == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

strcpy(chaine, "Light weight process $");
strcat(chaine, tampon);
}	}
}	}
else if ((*s_objet).type == FCH)	else if ((*s_objet).type == FCH)
Line 312 formateur(struct_processus *s_etat_proce	Line 269 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

sprintf(tampon, " %016lX", (unsigned long) (((struct_fichier )	if (alsprintf(&chaine, "File $ %016llX", (unsigned long long)
((*s_objet).objet))).descripteur);	(((struct_fichier ) ((*s_objet).objet))).descripteur) < 0)

chaine = (unsigned char *) malloc((strlen(tampon) + 7)
* sizeof(unsigned char));

if (chaine == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

strcpy(chaine, "File $");
strcat(chaine, tampon);

registre45 = test_cfsf(s_etat_processus, 45);	registre45 = test_cfsf(s_etat_processus, 45);
cf(s_etat_processus, 45);	cf(s_etat_processus, 45);

Line 452 formateur(struct_processus *s_etat_proce	Line 401 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

sprintf(tampon, " %016lX", (unsigned long) (((struct_socket )	if (alsprintf(&chaine, "Socket $ %016llX", (unsigned long long)
((*s_objet).objet))).socket);	(((struct_socket ) ((*s_objet).objet))).socket) < 0)

chaine = (unsigned char *) malloc((strlen(tampon) + 9)
* sizeof(unsigned char));

if (chaine == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

strcpy(chaine, "Socket $");
strcat(chaine, tampon);

registre45 = test_cfsf(s_etat_processus, 45);	registre45 = test_cfsf(s_etat_processus, 45);
cf(s_etat_processus, 45);	cf(s_etat_processus, 45);

Line 880 formateur(struct_processus *s_etat_proce	Line 821 formateur(struct_processus *s_etat_proce
chaine_sauvegarde = (unsigned char *)	chaine_sauvegarde = (unsigned char *)
(*s_sous_objet_2).objet;	(*s_sous_objet_2).objet;

if (((s_sous_objet_2).objet = (void )	if (((*s_sous_objet_2).objet =
malloc((strlen(chaine_sauvegarde) + 2 + 1)	malloc((strlen(chaine_sauvegarde) + 2 + 1)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
Line 1010 formateur(struct_processus *s_etat_proce	Line 951 formateur(struct_processus *s_etat_proce
chaine_sauvegarde = (unsigned char *)	chaine_sauvegarde = (unsigned char *)
(*s_sous_objet_1).objet;	(*s_sous_objet_1).objet;

if (((s_sous_objet_1).objet = (void )	if (((*s_sous_objet_1).objet =
malloc((strlen(chaine_sauvegarde) + 2 + 1)	malloc((strlen(chaine_sauvegarde) + 2 + 1)
* sizeof(unsigned char))) == NULL)	* sizeof(unsigned char))) == NULL)
{	{
Line 1034 formateur(struct_processus *s_etat_proce	Line 975 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

if (((s_sous_objet).objet = (void ) malloc((strlen(	if (((*s_sous_objet).objet = malloc((strlen(
(unsigned char ) (s_sous_objet_1).objet) +	(unsigned char ) (s_sous_objet_1).objet) +
strlen((((struct_fonction )	strlen((((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
Line 1115 formateur(struct_processus *s_etat_proce	Line 1056 formateur(struct_processus *s_etat_proce
if (autorisation_parenthese == d_vrai)	if (autorisation_parenthese == d_vrai)
{	{
if (((*s_sous_objet).objet =	if (((*s_sous_objet).objet =
(void *) malloc((strlen(	malloc((strlen(
(unsigned char ) (s_sous_objet_1).objet) +	(unsigned char ) (s_sous_objet_1).objet) +
strlen((((struct_fonction )	strlen((((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
Line 1139 formateur(struct_processus *s_etat_proce	Line 1080 formateur(struct_processus *s_etat_proce
else	else
{	{
if (((*s_sous_objet).objet =	if (((*s_sous_objet).objet =
(void *) malloc((strlen(	malloc((strlen(
(unsigned char ) (s_sous_objet_1).objet) +	(unsigned char ) (s_sous_objet_1).objet) +
strlen((((struct_fonction )	strlen((((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
Line 1393 formateur(struct_processus *s_etat_proce	Line 1334 formateur(struct_processus *s_etat_proce

liberation(s_etat_processus, s_sous_objet_3);	liberation(s_etat_processus, s_sous_objet_3);

if (((s_sous_objet).objet = (void ) malloc((strlen(	if (((*s_sous_objet).objet = malloc((strlen(
(unsigned char ) (s_sous_objet_1).objet) +	(unsigned char ) (s_sous_objet_1).objet) +
strlen((((struct_fonction )	strlen((((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
.nom_fonction) + strlen((unsigned char *)	.nom_fonction) + strlen((unsigned char *)
(*s_sous_objet_2).objet) + 2 + 1 +	(*s_sous_objet_2).objet) + 2 + 1 +
parentheses_groupe_gauche +	((size_t) parentheses_groupe_gauche) +
parentheses_groupe_droit) *	((size_t) parentheses_groupe_droit)) *
sizeof(unsigned char))) == NULL)	sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
Line 1537 formateur(struct_processus *s_etat_proce	Line 1478 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

(s_sous_objet).objet = (void ) chaine;	(*s_sous_objet).objet = chaine;

if (empilement(s_etat_processus, &((*s_etat_processus)	if (empilement(s_etat_processus, &((*s_etat_processus)
.l_base_pile), s_sous_objet) == d_erreur)	.l_base_pile), s_sous_objet) == d_erreur)
Line 1557 formateur(struct_processus *s_etat_proce	Line 1498 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

if (((s_sous_objet).objet = (void ) formateur(	if (((*s_sous_objet).objet = formateur(
s_etat_processus, 0, (*l_element_courant).donnee))	s_etat_processus, 0, (*l_element_courant).donnee))
== NULL)	== NULL)
{	{
Line 1585 formateur(struct_processus *s_etat_proce	Line 1526 formateur(struct_processus *s_etat_proce
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)) - 2;
i--, ptre++ = ptrl++);	i > 0; i--, ptre++ = ptrl++);

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

Line 1647 formateur(struct_processus *s_etat_proce	Line 1588 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

longueur_binaire = longueur_entiers_binaires(s_etat_processus);
masque_binaire = masque_entiers_binaires(s_etat_processus);	masque_binaire = masque_entiers_binaires(s_etat_processus);

if ((test_cfsf(s_etat_processus, 43) == d_faux) &&	if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
Line 1658 formateur(struct_processus *s_etat_proce	Line 1598 formateur(struct_processus *s_etat_proce
-- Base décimale ---------------------------------------------------------------	-- Base décimale ---------------------------------------------------------------
*/	*/

sprintf(tampon, "%llu", (((logical8 )	sprintf(tampon, "%llu", (((unsigned long long )
((*s_objet).objet))) & masque_binaire);	((*s_objet).objet))) & masque_binaire);
strcpy(base, "d");	strcpy(base, "d");
}	}
Line 1670 formateur(struct_processus *s_etat_proce	Line 1610 formateur(struct_processus *s_etat_proce
-- Base octale -----------------------------------------------------------------	-- Base octale -----------------------------------------------------------------
*/	*/

sprintf(tampon, "%llo", (((logical8 )	sprintf(tampon, "%llo", (((unsigned long long )
((*s_objet).objet))) & masque_binaire);	((*s_objet).objet))) & masque_binaire);
strcpy(base, "o");	strcpy(base, "o");
}	}
Line 1681 formateur(struct_processus *s_etat_proce	Line 1621 formateur(struct_processus *s_etat_proce
-- Bases hexadécimale et binaire -----------------------------------------------	-- Bases hexadécimale et binaire -----------------------------------------------
*/	*/

sprintf(tampon, "%llX", (((logical8 )	sprintf(tampon, "%llX", (((unsigned long long )
((*s_objet).objet))) & masque_binaire);	((*s_objet).objet))) & masque_binaire);

if (test_cfsf(s_etat_processus, 43) == d_vrai)	if (test_cfsf(s_etat_processus, 43) == d_vrai)
Line 1703 formateur(struct_processus *s_etat_proce	Line 1643 formateur(struct_processus *s_etat_proce
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 1819 formateur(struct_processus *s_etat_proce	Line 1759 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

chaine = (unsigned char ) malloc((strlen((unsigned char )	if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&
((s_objet).objet)) + 1) sizeof(unsigned char));	(test_cfsf(s_etat_processus, 34) == d_vrai))

if (chaine == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	if ((chaine = formateur_flux(s_etat_processus,
return(NULL);	(unsigned char ) (s_objet).objet, &longueur_chaine))
	== NULL)
	{
	return(NULL);
	}
}	}
	else
	{
	if ((chaine = malloc((strlen((unsigned char *)
	((s_objet).objet)) + 1) sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

strcpy(chaine, (unsigned char ) ((s_objet).objet));	strcpy(chaine, (unsigned char ) ((s_objet).objet));
	}
}	}
else if ((*s_objet).type == CPL)	else if ((*s_objet).type == CPL)
{	{
Line 1839 formateur(struct_processus *s_etat_proce	Line 1790 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

chaine_formatee = formateur_nombre(s_etat_processus, (void *)	chaine_formatee = formateur_nombre(s_etat_processus,
((struct_complexe16 ) ((s_objet).objet)), 'C');	((struct_complexe16 ) ((s_objet).objet)), 'C');

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 1874 formateur(struct_processus *s_etat_proce	Line 1825 formateur(struct_processus *s_etat_proce

while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
if ((chaine_formatee = formateur(s_etat_processus, 0,	if ((chaine_formatee = formateur(s_etat_processus, offset_initial,
(*l_element_courant).donnee)) == NULL)	(*l_element_courant).donnee)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 1947 formateur(struct_processus *s_etat_proce	Line 1898 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

chaine_formatee = formateur_nombre(s_etat_processus, (void *)	chaine_formatee = formateur_nombre(s_etat_processus,
((integer8 ) ((s_objet).objet)), 'I');	((integer8 ) ((s_objet).objet)), 'I');

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 2008 formateur(struct_processus *s_etat_proce	Line 1959 formateur(struct_processus *s_etat_proce
}	}

strcpy(chaine, "<[ ");	strcpy(chaine, "<[ ");
offset = strlen(chaine) + offset_initial;	offset = ((integer8) strlen(chaine)) + offset_initial;

for(i = 0; i < (((struct_tableau ) (*s_objet).objet))	for(i = 0; i < (((struct_tableau ) (*s_objet).objet))
.nombre_elements; i++)	.nombre_elements; i++)
{	{
chaine_sauvegarde = chaine;	chaine_sauvegarde = chaine;
chaine_formatee = formateur(s_etat_processus, offset,	chaine_formatee = formateur(s_etat_processus, (long) offset,
(((struct_tableau ) (*s_objet).objet)).elements[i]);	(((struct_tableau ) (*s_objet).objet)).elements[i]);

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 2105 formateur(struct_processus *s_etat_proce	Line 2056 formateur(struct_processus *s_etat_proce
chaine_sauvegarde = chaine;	chaine_sauvegarde = chaine;

chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) + 1 + offset)	(strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
* sizeof(unsigned char));	* sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2213 formateur(struct_processus *s_etat_proce	Line 2164 formateur(struct_processus *s_etat_proce

l_element_courant = (struct_liste_chainee ) ((s_objet).objet);	l_element_courant = (struct_liste_chainee ) ((s_objet).objet);
nombre_elements = 0;	nombre_elements = 0;
offset = strlen(chaine) + offset_initial;	offset = ((integer8) strlen(chaine)) + offset_initial;

while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
chaine_sauvegarde = chaine;	chaine_sauvegarde = chaine;
chaine_formatee = formateur(s_etat_processus, offset,	chaine_formatee = formateur(s_etat_processus, (long) offset,
(*l_element_courant).donnee);	(*l_element_courant).donnee);

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 2307 formateur(struct_processus *s_etat_proce	Line 2258 formateur(struct_processus *s_etat_proce
chaine_sauvegarde = chaine;	chaine_sauvegarde = chaine;

chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) + 1 + offset)	(strlen(chaine_sauvegarde) + 1 + ((size_t) offset))
* sizeof(unsigned char));	* sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2415 formateur(struct_processus *s_etat_proce	Line 2366 formateur(struct_processus *s_etat_proce
if (chaine != NULL)	if (chaine != NULL)
{	{
strcpy(chaine, "[[");	strcpy(chaine, "[[");
offset = strlen(chaine) + offset_initial - 1;	offset = ((integer8) strlen(chaine)) + offset_initial - 1;

if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *	if ((longueurs_maximales = malloc(sizeof(integer8) * 2 *
nombre_colonnes)) == NULL)	((size_t) nombre_colonnes))) == NULL)
{	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
Line 2437 formateur(struct_processus *s_etat_proce	Line 2388 formateur(struct_processus *s_etat_proce
for(j = 0; j < nombre_colonnes; j++)	for(j = 0; j < nombre_colonnes; j++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus,	chaine_formatee = formateur_nombre(s_etat_processus,
(void ) &(((struct_complexe16 *)	&(((struct_complexe16 **)
((((struct_matrice )	((((struct_matrice )
((*s_objet).objet))).tableau))[i][j]), 'C');	((*s_objet).objet))).tableau))[i][j]), 'C');

Line 2448 formateur(struct_processus *s_etat_proce	Line 2399 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

longueur_courante = strlen(chaine_formatee);	longueur_courante = (integer8) strlen(chaine_formatee);
longueur_decimale_courante = 0;	longueur_decimale_courante = 0;

if ((ptrl = index(chaine_formatee,	if ((ptrl = index(chaine_formatee,
Line 2482 formateur(struct_processus *s_etat_proce	Line 2433 formateur(struct_processus *s_etat_proce
for(j = 0; j < nombre_colonnes; j++)	for(j = 0; j < nombre_colonnes; j++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus,	chaine_formatee = formateur_nombre(s_etat_processus,
(void ) &(((struct_complexe16 *)	&(((struct_complexe16 **)
((((struct_matrice )	((((struct_matrice )
((*s_objet).objet))).tableau))[i][j]), 'C');	((*s_objet).objet))).tableau))[i][j]), 'C');

Line 2493 formateur(struct_processus *s_etat_proce	Line 2444 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

longueur_courante = strlen(chaine_formatee);	longueur_courante = (integer8) strlen(chaine_formatee);
longueur_decimale_courante = 0;	longueur_decimale_courante = 0;

if ((ptrl = index(chaine_formatee,	if ((ptrl = index(chaine_formatee,
Line 2512 formateur(struct_processus *s_etat_proce	Line 2463 formateur(struct_processus *s_etat_proce

chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) +	(strlen(chaine_sauvegarde) +
longueur_courante + longueur_decimale_courante +	((size_t) longueur_courante) +
longueurs_maximales[2 * j] +	((size_t) longueur_decimale_courante) +
longueurs_maximales[(2 * j) + 1] + 2)	((size_t) longueurs_maximales[2 * j]) +
	((size_t) longueurs_maximales[(2 * j) + 1]) + 2)
* sizeof(unsigned char));	* sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2547 formateur(struct_processus *s_etat_proce	Line 2499 formateur(struct_processus *s_etat_proce
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) +	(strlen(chaine_sauvegarde) +
longueur_courante + longueur_decimale_courante	((size_t) longueur_courante) +
	((size_t) longueur_decimale_courante)
+ 2) * sizeof(unsigned char));	+ 2) * sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2573 formateur(struct_processus *s_etat_proce	Line 2526 formateur(struct_processus *s_etat_proce
if (test_cfsf(s_etat_processus, 45) == d_vrai)	if (test_cfsf(s_etat_processus, 45) == d_vrai)
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) + 5 + offset)	(strlen(chaine_sauvegarde) + 5 +
* sizeof(unsigned char));	((size_t) offset)) * sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
{	{
Line 2649 formateur(struct_processus *s_etat_proce	Line 2602 formateur(struct_processus *s_etat_proce
if (chaine != NULL)	if (chaine != NULL)
{	{
strcpy(chaine, "[[");	strcpy(chaine, "[[");
offset = strlen(chaine) + offset_initial - 1;	offset = ((integer8) strlen(chaine)) + offset_initial - 1;

if ((longueurs_maximales = malloc(sizeof(unsigned long) *	if ((longueurs_maximales = malloc(sizeof(integer8) *
nombre_colonnes)) == NULL)	((size_t) nombre_colonnes))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2670 formateur(struct_processus *s_etat_proce	Line 2623 formateur(struct_processus *s_etat_proce
for(j = 0; j < nombre_colonnes; j++)	for(j = 0; j < nombre_colonnes; j++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus,	chaine_formatee = formateur_nombre(s_etat_processus,
(void ) &(((integer8 ) ((((struct_matrice *)	&(((integer8 *) ((((struct_matrice *)
((*s_objet).objet))).tableau))[i][j]), 'I');	((*s_objet).objet))).tableau))[i][j]), 'I');

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 2680 formateur(struct_processus *s_etat_proce	Line 2633 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

longueur_courante = strlen(chaine_formatee);	longueur_courante = (integer8) strlen(chaine_formatee);
free(chaine_formatee);	free(chaine_formatee);

if (longueurs_maximales[j] < longueur_courante)	if (longueurs_maximales[j] < longueur_courante)
Line 2696 formateur(struct_processus *s_etat_proce	Line 2649 formateur(struct_processus *s_etat_proce
for(j = 0; j < nombre_colonnes; j++)	for(j = 0; j < nombre_colonnes; j++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus,	chaine_formatee = formateur_nombre(s_etat_processus,
(void ) &(((integer8 ) ((((struct_matrice *)	&(((integer8 *) ((((struct_matrice *)
((*s_objet).objet))).tableau))[i][j]), 'I');	((*s_objet).objet))).tableau))[i][j]), 'I');

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 2706 formateur(struct_processus *s_etat_proce	Line 2659 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

longueur_courante = strlen(chaine_formatee);	longueur_courante = (integer8) strlen(chaine_formatee);
chaine_sauvegarde = chaine;	chaine_sauvegarde = chaine;

if (test_cfsf(s_etat_processus, 45) == d_vrai)	if (test_cfsf(s_etat_processus, 45) == d_vrai)
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) + longueur_courante	(strlen(chaine_sauvegarde) +
+ longueurs_maximales[j] + 2)	((size_t) longueur_courante)
	+ ((size_t) longueurs_maximales[j]) + 2)
* sizeof(unsigned char));	* sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2737 formateur(struct_processus *s_etat_proce	Line 2691 formateur(struct_processus *s_etat_proce
else	else
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) + longueur_courante	(strlen(chaine_sauvegarde) +
	((size_t) longueur_courante)
+ 2) * sizeof(unsigned char));	+ 2) * sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2763 formateur(struct_processus *s_etat_proce	Line 2718 formateur(struct_processus *s_etat_proce
if (test_cfsf(s_etat_processus, 45) == d_vrai)	if (test_cfsf(s_etat_processus, 45) == d_vrai)
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) + 5 + offset)	(strlen(chaine_sauvegarde) + 5 +
* sizeof(unsigned char));	((size_t) offset)) * sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
{	{
Line 2839 formateur(struct_processus *s_etat_proce	Line 2794 formateur(struct_processus *s_etat_proce
if (chaine != NULL)	if (chaine != NULL)
{	{
strcpy(chaine, "[[");	strcpy(chaine, "[[");
offset = strlen(chaine) + offset_initial - 1;	offset = ((integer8) strlen(chaine)) + offset_initial - 1;

if ((longueurs_maximales = malloc(sizeof(unsigned long) * 2 *	if ((longueurs_maximales = malloc(sizeof(integer8) * 2 *
nombre_colonnes)) == NULL)	((size_t) nombre_colonnes))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2860 formateur(struct_processus *s_etat_proce	Line 2815 formateur(struct_processus *s_etat_proce
for(j = 0; j < nombre_colonnes; j++)	for(j = 0; j < nombre_colonnes; j++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus,	chaine_formatee = formateur_nombre(s_etat_processus,
(void ) &(((real8 ) ((((struct_matrice *)	&(((real8 *) ((((struct_matrice *)
((*s_objet).objet))).tableau))[i][j]), 'R');	((*s_objet).objet))).tableau))[i][j]), 'R');

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 2870 formateur(struct_processus *s_etat_proce	Line 2825 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

longueur_courante = strlen(chaine_formatee);	longueur_courante = (integer8) strlen(chaine_formatee);
longueur_decimale_courante = 0;	longueur_decimale_courante = 0;

if ((ptrl = index(chaine_formatee,	if ((ptrl = index(chaine_formatee,
Line 2904 formateur(struct_processus *s_etat_proce	Line 2859 formateur(struct_processus *s_etat_proce
for(j = 0; j < nombre_colonnes; j++)	for(j = 0; j < nombre_colonnes; j++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus,	chaine_formatee = formateur_nombre(s_etat_processus,
(void ) &(((real8 ) ((((struct_matrice *)	&(((real8 *) ((((struct_matrice *)
((*s_objet).objet))).tableau))[i][j]), 'R');	((*s_objet).objet))).tableau))[i][j]), 'R');

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 2914 formateur(struct_processus *s_etat_proce	Line 2869 formateur(struct_processus *s_etat_proce
return(NULL);	return(NULL);
}	}

longueur_courante = strlen(chaine_formatee);	longueur_courante = (integer8) strlen(chaine_formatee);
longueur_decimale_courante = 0;	longueur_decimale_courante = 0;

if ((ptrl = index(chaine_formatee,	if ((ptrl = index(chaine_formatee,
Line 2932 formateur(struct_processus *s_etat_proce	Line 2887 formateur(struct_processus *s_etat_proce
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) +	(strlen(chaine_sauvegarde) +
longueur_courante + longueur_decimale_courante +	((size_t) longueur_courante) +
longueurs_maximales[2 * j] +	((size_t) longueur_decimale_courante) +
longueurs_maximales[(2 * j) + 1] + 2)	((size_t) longueurs_maximales[2 * j]) +
	((size_t) longueurs_maximales[(2 * j) + 1]) + 2)
* sizeof(unsigned char));	* sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2967 formateur(struct_processus *s_etat_proce	Line 2923 formateur(struct_processus *s_etat_proce
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) +	(strlen(chaine_sauvegarde) +
longueur_courante + longueur_decimale_courante	((size_t) longueur_courante) +
	((size_t) longueur_decimale_courante)
+ 2) * sizeof(unsigned char));	+ 2) * sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
Line 2993 formateur(struct_processus *s_etat_proce	Line 2950 formateur(struct_processus *s_etat_proce
if (test_cfsf(s_etat_processus, 45) == d_vrai)	if (test_cfsf(s_etat_processus, 45) == d_vrai)
{	{
chaine = (unsigned char *) malloc(	chaine = (unsigned char *) malloc(
(strlen(chaine_sauvegarde) + 5 + offset)	(strlen(chaine_sauvegarde) + 5 +
* sizeof(unsigned char));	((size_t) offset)) * sizeof(unsigned char));

if (chaine == NULL)	if (chaine == NULL)
{	{
Line 3052 formateur(struct_processus *s_etat_proce	Line 3009 formateur(struct_processus *s_etat_proce
}	}
else if ((*s_objet).type == MTX)	else if ((*s_objet).type == MTX)
{	{
sprintf(tampon, " %016lX", (unsigned long)	if (alsprintf(&chaine, "Mutex $ %016llX owned by $ %016llX",
&((((struct_mutex ) (*s_objet).objet)).mutex));	&((((struct_mutex ) (*s_objet).objet)).mutex),
	(logical8) (((struct_mutex ) (*s_objet).objet)).tid) < 0)
chaine = (unsigned char *) malloc((strlen(tampon) + 8)
* sizeof(unsigned char));

if (chaine == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

strcpy(chaine, "Mutex $");
strcat(chaine, tampon);
}	}
else if ((*s_objet).type == NOM)	else if ((*s_objet).type == NOM)
{	{
Line 3112 formateur(struct_processus *s_etat_proce	Line 3062 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

chaine_formatee = formateur_nombre(s_etat_processus, (void *)	chaine_formatee = formateur_nombre(s_etat_processus,
((real8 ) ((s_objet).objet)), 'R');	((real8 ) ((s_objet).objet)), 'R');

if (chaine_formatee == NULL)	if (chaine_formatee == NULL)
Line 3153 formateur(struct_processus *s_etat_proce	Line 3103 formateur(struct_processus *s_etat_proce

for(i = 0; i < nombre_colonnes; i++)	for(i = 0; i < nombre_colonnes; i++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus, (void *)	chaine_formatee = formateur_nombre(s_etat_processus,
&(((struct_complexe16 ) ((((struct_vecteur *)	&(((struct_complexe16 ) ((((struct_vecteur *)
((*s_objet).objet))).tableau))[i]), 'C');	((*s_objet).objet))).tableau))[i]), 'C');

Line 3220 formateur(struct_processus *s_etat_proce	Line 3170 formateur(struct_processus *s_etat_proce

for(i = 0; i < nombre_colonnes; i++)	for(i = 0; i < nombre_colonnes; i++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus, (void *)	chaine_formatee = formateur_nombre(s_etat_processus,
&(((integer8 ) ((((struct_vecteur *)	&(((integer8 ) ((((struct_vecteur *)
((*s_objet).objet))).tableau))[i]), 'I');	((*s_objet).objet))).tableau))[i]), 'I');

Line 3287 formateur(struct_processus *s_etat_proce	Line 3237 formateur(struct_processus *s_etat_proce

for(i = 0; i < nombre_colonnes; i++)	for(i = 0; i < nombre_colonnes; i++)
{	{
chaine_formatee = formateur_nombre(s_etat_processus, (void *)	chaine_formatee = formateur_nombre(s_etat_processus,
&(((real8 ) ((((struct_vecteur *)	&(((real8 ) ((((struct_vecteur *)
((*s_objet).objet))).tableau))[i]), 'R');	((*s_objet).objet))).tableau))[i]), 'R');

Line 3387 formateur_nombre(struct_processus *s_eta	Line 3337 formateur_nombre(struct_processus *s_eta
strcpy(construction_chaine, "(");	strcpy(construction_chaine, "(");

tampon = formateur_reel(s_etat_processus,	tampon = formateur_reel(s_etat_processus,
(void ) &((((struct_complexe16 *)	&((((struct_complexe16 )
valeur_numerique)).partie_reelle), 'R');	valeur_numerique)).partie_reelle), 'R');

if (tampon == NULL)	if (tampon == NULL)
Line 3425 formateur_nombre(struct_processus *s_eta	Line 3375 formateur_nombre(struct_processus *s_eta
}	}

tampon = formateur_reel(s_etat_processus,	tampon = formateur_reel(s_etat_processus,
(void ) &((((struct_complexe16 *)	&((((struct_complexe16 )
valeur_numerique)).partie_imaginaire), 'R');	valeur_numerique)).partie_imaginaire), 'R');

if (tampon == NULL)	if (tampon == NULL)
Line 3512 formateur_reel(struct_processus *s_etat_	Line 3462 formateur_reel(struct_processus *s_etat_
logical1 i50;	logical1 i50;

long correction;	long correction;
	long dernier_chiffre_significatif;
long exposant;	long exposant;
	long i;
	long j;
long longueur_utile;	long longueur_utile;
long longueur_utile_limite;	long longueur_utile_limite;

unsigned char *chaine;	unsigned char *chaine;
unsigned char format[16 + 1];	unsigned char format[32 + 1];
unsigned char mode[3 + 1];	unsigned char mode[3 + 1];
unsigned char *ptr;	unsigned char *ptr;
unsigned char tampon[16 + 1];	unsigned char tampon[32 + 1];

unsigned long i;
unsigned long j;

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

Line 3536 formateur_reel(struct_processus *s_etat_	Line 3486 formateur_reel(struct_processus *s_etat_

if (type == 'R')	if (type == 'R')
{	{
	# ifdef FP_INFINITE
	int signe;

	if ((signe = isinf((((real8 ) valeur_numerique)))) != 0)
	{
	if (signe > 0)
	{
	strcpy(chaine, "infinity");
	}
	else
	{
	strcpy(chaine, "-infinity");
	}

	return(chaine);
	}
	# endif

	if (isnan((((real8 ) valeur_numerique))))
	{
	strcpy(chaine, "undef");
	return(chaine);
	}

tampon_reel = ((real8 ) valeur_numerique);	tampon_reel = ((real8 ) valeur_numerique);

if (tampon_reel > ((real8) 0))	if (tampon_reel > ((real8) 0))
Line 3551 formateur_reel(struct_processus *s_etat_	Line 3525 formateur_reel(struct_processus *s_etat_
exposant = 0;	exposant = 0;
}	}

mantisse = (((real8 ) valeur_numerique)) / pow(10, exposant);	mantisse = (((real8 ) valeur_numerique)) / pow(10, (double) exposant);
}	}
else	else
{	{
Line 3559 formateur_reel(struct_processus *s_etat_	Line 3533 formateur_reel(struct_processus *s_etat_

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));	if (tampon_entier != INT64_MIN)
	{
	exposant = (long) floor(log10((double) -tampon_entier));
	}
	else
	{
	tampon_reel = (real8) tampon_entier;
	exposant = (long) floor(log10(-tampon_reel));
	}
}	}
else	else
{	{
exposant = 0;	exposant = 0;
}	}

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

longueur_utile = 0;	longueur_utile = 0;
Line 3644 formateur_reel(struct_processus *s_etat_	Line 3627 formateur_reel(struct_processus *s_etat_
}	}
}	}

	// Test portant sur le nombre de chiffres significatifs dans
	// le cas du format STD pour que 1.2E-15 apparaisse en notation
	// SCI car il y a une perte de précision dans l'affichage.

	if ((strcmp(mode, "STD") == 0) && (type == 'R'))
	{
	if (abs(((real8 ) valeur_numerique)) < 1)
	{
	dernier_chiffre_significatif = -exposant;
	sprintf(tampon, ".%f", mantisse);

	ptr = &(tampon[strlen(tampon) - 1]);

	while((*ptr) != '.')
	{
	if ((*ptr) != '0')
	{
	dernier_chiffre_significatif++;
	}

	ptr--;
	}
	}
	else
	{
	dernier_chiffre_significatif = 0;
	}
	}
	else
	{
	dernier_chiffre_significatif = 0;
	}

if ((strcmp(mode, "SCI") == 0) \|\|	if ((strcmp(mode, "SCI") == 0) \|\|
((strcmp(mode, "STD") == 0) && ((exposant >	((strcmp(mode, "STD") == 0) && ((exposant >
longueur_utile_limite) \|\|	longueur_utile_limite) \|\| (dernier_chiffre_significatif > 15) \|\|
(exposant < -longueur_utile_limite))) \|\|	(exposant < -longueur_utile_limite))) \|\|
((strcmp(mode, "FIX") == 0) &&	((strcmp(mode, "FIX") == 0) &&
((exposant >= longueur_utile_limite) \|\|	((exposant >= longueur_utile_limite) \|\|
Line 3690 formateur_reel(struct_processus *s_etat_	Line 3706 formateur_reel(struct_processus *s_etat_

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 3713 formateur_reel(struct_processus *s_etat_	Line 3729 formateur_reel(struct_processus *s_etat_
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 3733 formateur_reel(struct_processus *s_etat_	Line 3749 formateur_reel(struct_processus *s_etat_

if (exposant >= 0)	if (exposant >= 0)
{	{
sprintf(format, "%%.%luf", (longueur_utile_limite - exposant	if ((exposant + 1) < longueur_utile_limite)
- 1));	{
	sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
	- 1));
	}
	else
	{
	strcpy(format, "%.0f.");
	}
}	}
else	else
{	{
Line 3743 formateur_reel(struct_processus *s_etat_	Line 3766 formateur_reel(struct_processus *s_etat_

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

i = strlen(tampon) - 1;	i = ((long) strlen(tampon)) - 1;
while(tampon[i] == '0')	while(tampon[i] == '0')
{	{
tampon[i] = d_code_fin_chaine;	tampon[i] = d_code_fin_chaine;
Line 3752 formateur_reel(struct_processus *s_etat_	Line 3775 formateur_reel(struct_processus *s_etat_

if (ds_imposition_separateur_decimal == d_faux)	if (ds_imposition_separateur_decimal == d_faux)
{	{
i = strlen(tampon) - 1;	i = ((long) strlen(tampon)) - 1;
if (tampon[i] == '.')	if (tampon[i] == '.')
{	{
tampon[i] = d_code_fin_chaine;	tampon[i] = d_code_fin_chaine;
}	}
}	}
}	}

strcpy(chaine, tampon);	strcpy(chaine, tampon);
}	}

if (test_cfsf(s_etat_processus, 48) == d_vrai)	if (test_cfsf(s_etat_processus, 48) == d_vrai)
{	{
for(i = 0; i < strlen(chaine); i++)	for(i = 0; i < (long) strlen(chaine); i++)
{	{
if (chaine[i] == '.')	if (chaine[i] == '.')
{	{

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.1
changed lines
	Added in v.1.69