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.24.2.4 and 1.93

version 1.24.2.4, 2011/05/09 13:52:11	version 1.93, 2019/01/01 09:02:51
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.24	RPL/2 (R) version 4.1.30
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2019 Dr. BERTRAND Joël

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

Line 42 formateur(struct_processus *s_etat_proce	Line 42 formateur(struct_processus *s_etat_proce
int parentheses_groupe_gauche;	int parentheses_groupe_gauche;
int parentheses_groupe_droit;	int parentheses_groupe_droit;

	integer8 (__type_disp)(struct_processus , void **);

logical1 registre45;	logical1 registre45;

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 67 formateur(struct_processus *s_etat_proce	Line 71 formateur(struct_processus *s_etat_proce
unsigned char *format_majuscule;	unsigned char *format_majuscule;
unsigned char *ptre;	unsigned char *ptre;
unsigned char *ptrl;	unsigned char *ptrl;
unsigned char *ptr_ecriture;
unsigned char *ptr_lecture;
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 94 formateur(struct_processus *s_etat_proce	Line 94 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 106 formateur(struct_processus *s_etat_proce	Line 105 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "@ %016lX", (((unsigned long )	if (alsprintf(s_etat_processus, &chaine,
	"@ %016llX", (((unsigned long long )
((*s_objet).objet)))) < 0)	((*s_objet).objet)))) < 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 122 formateur(struct_processus *s_etat_proce	Line 122 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "Library $ %016lX [%s]",	# pragma GCC diagnostic push
(unsigned long) (((struct_bibliotheque )	# pragma GCC diagnostic ignored "-Wpointer-to-int-cast"

	if (alsprintf(s_etat_processus, &chaine, "Library $ %016llX [%s]",
	(unsigned long long) (((struct_bibliotheque )
(s_objet).objet)).descripteur, (((struct_bibliotheque *)	(s_objet).objet)).descripteur, (((struct_bibliotheque *)
(*s_objet).objet)).nom) < 0)	(*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);
}	}

	# pragma GCC diagnostic pop

}	}
else if ((*s_objet).type == SPH)	else if ((*s_objet).type == SPH)
{	{
Line 140 formateur(struct_processus *s_etat_proce	Line 146 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "Semaphore $ %016lX '%s'",	# pragma GCC diagnostic push
	# pragma GCC diagnostic ignored "-Wpointer-to-int-cast"

	if (alsprintf(s_etat_processus,
	&chaine, "Semaphore $ %016llX '%s'", (unsigned long long)
&((((struct_semaphore ) (*s_objet).objet)).semaphore),	&((((struct_semaphore ) (*s_objet).objet)).semaphore),
(((struct_semaphore ) (*s_objet).objet)).nom) < 0)	(((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);
}	}

	# pragma GCC diagnostic pop

}	}
else if ((*s_objet).type == SQL)	else if ((*s_objet).type == SQL)
{	{
Line 161 formateur(struct_processus *s_etat_proce	Line 174 formateur(struct_processus *s_etat_proce
"MYSQL") == 0)	"MYSQL") == 0)
{	{
# ifdef MYSQL_SUPPORT	# ifdef MYSQL_SUPPORT
if (alsprintf(&chaine, "Sql $ %016lX (%s)",	if (alsprintf(s_etat_processus, &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) < 0)	(((struct_connecteur_sql ) (*s_objet).objet)).type) < 0)
{	{
Line 188 formateur(struct_processus *s_etat_proce	Line 201 formateur(struct_processus *s_etat_proce
"POSTGRESQL") == 0)	"POSTGRESQL") == 0)
{	{
# ifdef POSTGRESQL_SUPPORT	# ifdef POSTGRESQL_SUPPORT
if (alsprintf(&chaine, "Sql $ %016lX (%s)",	if (alsprintf(s_etat_processus, &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) < 0)	(((struct_connecteur_sql ) (*s_objet).objet)).type) < 0)
{	{
Line 230 formateur(struct_processus *s_etat_proce	Line 243 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)
{	{
if (alsprintf(&chaine, "Process $ %016lX", (unsigned long)	if (alsprintf(s_etat_processus, &chaine,
	"Process $ %016llX", (unsigned long long)
((((struct_processus_fils ) (s_objet).objet)).thread)	((((struct_processus_fils ) (s_objet).objet)).thread)
.pid) < 0)	.pid) < 0)
{	{
Line 240 formateur(struct_processus *s_etat_proce	Line 254 formateur(struct_processus *s_etat_proce
}	}
else	else
{	{
if (alsprintf(&chaine, "Light weight process $ %016lX/%016lX",	if (alsprintf(s_etat_processus, &chaine,
(unsigned long) ((((struct_processus_fils *)	"Light weight process $ %016llX/%016llX",
	(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) < 0)	(*s_objet).objet)).thread).tid) < 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 260 formateur(struct_processus *s_etat_proce	Line 275 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "File $ %016lX", (unsigned long)	if (alsprintf(s_etat_processus,
	&chaine, "File $ %016llX", (unsigned long long)
(((struct_fichier ) ((*s_objet).objet))).descripteur) < 0)	(((struct_fichier ) ((*s_objet).objet))).descripteur) < 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 285 formateur(struct_processus *s_etat_proce	Line 301 formateur(struct_processus *s_etat_proce
cf(s_etat_processus, 45);	cf(s_etat_processus, 45);
}	}

if ((format_majuscule = conversion_majuscule(format)) == NULL)	if ((format_majuscule = conversion_majuscule(s_etat_processus,
	format)) == NULL)
{	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}

Line 392 formateur(struct_processus *s_etat_proce	Line 410 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "Socket $ %016lX",	if (alsprintf(s_etat_processus, &chaine,
(unsigned long) (((struct_socket )	"Socket $ %016llX", (unsigned long long)
((*s_objet).objet))).socket) < 0)	(((struct_socket ) ((*s_objet).objet))).socket) < 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 418 formateur(struct_processus *s_etat_proce	Line 436 formateur(struct_processus *s_etat_proce
cf(s_etat_processus, 45);	cf(s_etat_processus, 45);
}	}

if ((format_majuscule = conversion_majuscule(format)) == NULL)	if ((format_majuscule = conversion_majuscule(s_etat_processus,
	format)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 691 formateur(struct_processus *s_etat_proce	Line 710 formateur(struct_processus *s_etat_proce
\|\| ((*s_etat_processus).instruction_courante[1]	\|\| ((*s_etat_processus).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 748 formateur(struct_processus *s_etat_proce	Line 768 formateur(struct_processus *s_etat_proce
{	{
if ((strcmp(chaine_fonction, "AND") == 0) \|\|	if ((strcmp(chaine_fonction, "AND") == 0) \|\|
(strcmp(chaine_fonction, "XOR") == 0) \|\|	(strcmp(chaine_fonction, "XOR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV") == 0) \|\|
(strcmp(chaine_fonction, "OR") == 0))	(strcmp(chaine_fonction, "OR") == 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
Line 774 formateur(struct_processus *s_etat_proce	Line 795 formateur(struct_processus *s_etat_proce
(strcmp(chaine_fonction, "-") == 0) \|\|	(strcmp(chaine_fonction, "-") == 0) \|\|
(strcmp(chaine_fonction, "AND") == 0) \|\|	(strcmp(chaine_fonction, "AND") == 0) \|\|
(strcmp(chaine_fonction, "XOR") == 0) \|\|	(strcmp(chaine_fonction, "XOR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV") == 0) \|\|
(strcmp(chaine_fonction, "OR") == 0))	(strcmp(chaine_fonction, "OR") == 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
Line 813 formateur(struct_processus *s_etat_proce	Line 835 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 854 formateur(struct_processus *s_etat_proce	Line 876 formateur(struct_processus *s_etat_proce
"'%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 909 formateur(struct_processus *s_etat_proce	Line 932 formateur(struct_processus *s_etat_proce
{	{
if ((strcmp(chaine_fonction, "AND") == 0) \|\|	if ((strcmp(chaine_fonction, "AND") == 0) \|\|
(strcmp(chaine_fonction, "XOR") == 0) \|\|	(strcmp(chaine_fonction, "XOR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV") == 0) \|\|
(strcmp(chaine_fonction, "OR") == 0))	(strcmp(chaine_fonction, "OR") == 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
Line 925 formateur(struct_processus *s_etat_proce	Line 949 formateur(struct_processus *s_etat_proce
(strcmp(chaine_fonction, "-") == 0) \|\|	(strcmp(chaine_fonction, "-") == 0) \|\|
(strcmp(chaine_fonction, "AND") == 0) \|\|	(strcmp(chaine_fonction, "AND") == 0) \|\|
(strcmp(chaine_fonction, "XOR") == 0) \|\|	(strcmp(chaine_fonction, "XOR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV") == 0) \|\|
(strcmp(chaine_fonction, "OR") == 0))	(strcmp(chaine_fonction, "OR") == 0))
{	{
autorisation_parenthese = d_vrai;	autorisation_parenthese = d_vrai;
Line 943 formateur(struct_processus *s_etat_proce	Line 968 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 967 formateur(struct_processus *s_etat_proce	Line 992 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 1048 formateur(struct_processus *s_etat_proce	Line 1073 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 1072 formateur(struct_processus *s_etat_proce	Line 1097 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 1151 formateur(struct_processus *s_etat_proce	Line 1176 formateur(struct_processus *s_etat_proce
((l_element_courant).donnee).objet)).nom_fonction,	((l_element_courant).donnee).objet)).nom_fonction,
"XOR") == 0) \|\| (strcmp((((struct_fonction )	"XOR") == 0) \|\| (strcmp((((struct_fonction )
((l_element_courant).donnee).objet)).nom_fonction,	((l_element_courant).donnee).objet)).nom_fonction,
	"EQV") == 0) \|\| (strcmp((((struct_fonction )
	((l_element_courant).donnee).objet)).nom_fonction,
"AND") == 0))	"AND") == 0))
{	{
if (depilement(s_etat_processus, &((*s_etat_processus)	if (depilement(s_etat_processus, &((*s_etat_processus)
Line 1195 formateur(struct_processus *s_etat_proce	Line 1222 formateur(struct_processus *s_etat_proce
"'%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 1240 formateur(struct_processus *s_etat_proce	Line 1268 formateur(struct_processus *s_etat_proce
}	}

if (((strcmp(chaine_fonction, "OR") == 0) \|\|	if (((strcmp(chaine_fonction, "OR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV") == 0) \|\|
(strcmp(chaine_fonction, "XOR") == 0)) &&	(strcmp(chaine_fonction, "XOR") == 0)) &&
(strcmp((((struct_fonction )	(strcmp((((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
Line 1270 formateur(struct_processus *s_etat_proce	Line 1299 formateur(struct_processus *s_etat_proce
"'%s'", (unsigned char *)	"'%s'", (unsigned char *)
(*s_sous_objet_2).objet);	(*s_sous_objet_2).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 1315 formateur(struct_processus *s_etat_proce	Line 1345 formateur(struct_processus *s_etat_proce
}	}

if (((strcmp(chaine_fonction, "OR") == 0) \|\|	if (((strcmp(chaine_fonction, "OR") == 0) \|\|
	(strcmp(chaine_fonction, "EQV") == 0) \|\|
(strcmp(chaine_fonction, "XOR") == 0)) &&	(strcmp(chaine_fonction, "XOR") == 0)) &&
(strcmp((((struct_fonction )	(strcmp((((struct_fonction )
((l_element_courant).donnee).objet))	((l_element_courant).donnee).objet))
Line 1326 formateur(struct_processus *s_etat_proce	Line 1357 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 1470 formateur(struct_processus *s_etat_proce	Line 1501 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 1490 formateur(struct_processus *s_etat_proce	Line 1521 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 1518 formateur(struct_processus *s_etat_proce	Line 1549 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 1580 formateur(struct_processus *s_etat_proce	Line 1611 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 1591 formateur(struct_processus *s_etat_proce	Line 1621 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 1603 formateur(struct_processus *s_etat_proce	Line 1633 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 1614 formateur(struct_processus *s_etat_proce	Line 1644 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 1636 formateur(struct_processus *s_etat_proce	Line 1666 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 1752 formateur(struct_processus *s_etat_proce	Line 1782 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

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);
}

if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&	if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&
(test_cfsf(s_etat_processus, 34) == d_vrai))	(test_cfsf(s_etat_processus, 34) == d_vrai))
{	{
ptr_lecture = (unsigned char ) (s_objet).objet;	if ((chaine = formateur_flux(s_etat_processus,
ptr_ecriture = chaine;	(unsigned char ) (s_objet).objet, &longueur_chaine))
	== NULL)
while((*ptr_lecture) != d_code_fin_chaine)
{
(ptr_ecriture) = (ptr_lecture);

// Début de la séquence d'échappement

if ((*ptr_lecture) == '\\')
{
if ((*(ptr_lecture + 1)) == '"')
{
ptr_lecture++;
(*ptr_ecriture) = '\"';
}
else if ((*(ptr_lecture + 1)) == 'b')
{
ptr_lecture++;
(*ptr_ecriture) = '\b';
}
else if ((*(ptr_lecture + 1)) == 'n')
{
ptr_lecture++;
(*ptr_ecriture) = '\n';
}
else if ((*(ptr_lecture + 1)) == 't')
{
ptr_lecture++;
(*ptr_ecriture) = '\t';
}
else if ((*(ptr_lecture + 1)) == 'x')
{
ptr_lecture += 2;

if ((*ptr_lecture) != d_code_fin_chaine)
{
if ((*(ptr_lecture + 1)) != d_code_fin_chaine)
{
logical1 erreur;
unsigned char ec;

erreur = d_faux;

switch(*ptr_lecture)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
ec = (*ptr_lecture) - '0';
break;

case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
ec = ((*ptr_lecture) - 'A') + 10;
break;

default:
ec = 0;
erreur = d_vrai;
break;
}

ec *= 0x10;
ptr_lecture++;

switch(*ptr_lecture)
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
ec += (*ptr_lecture) - '0';
break;

case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
ec += ((*ptr_lecture) - 'A') + 10;
break;

default:
erreur = d_vrai;
break;
}

(*ptr_ecriture) = ec;

if (erreur == d_vrai)
{
if ((*s_etat_processus).langue == 'F')
{
printf("+++Information : "
"Séquence d'échappement "
"inconnue [%d]\n",
(int) getpid());
}
else
{
printf("+++Warning : Unknown "
"escape code "
"[%d]\n", (int) getpid());
}
}
}
else
{
if ((*s_etat_processus).langue == 'F')
{
printf("+++Information : "
"Séquence d'échappement "
"inconnue [%d]\n", (int) getpid());
}
else
{
printf("+++Warning : Unknown escape code "
"[%d]\n", (int) getpid());
}
}
}
else
{
if ((*s_etat_processus).langue == 'F')
{
printf("+++Information : "
"Séquence d'échappement "
"inconnue [%d]\n", (int) getpid());
}
else
{
printf("+++Warning : Unknown escape code "
"[%d]\n", (int) getpid());
}
}
}
else if ((*(ptr_lecture + 1)) == '\\')
{
ptr_lecture++;
}
else
{
if ((*s_etat_processus).langue == 'F')
{
printf("+++Information : Séquence d'échappement "
"inconnue [%d]\n", (int) getpid());
}
else
{
printf("+++Warning : Unknown escape code "
"[%d]\n", (int) getpid());
}
}
}

ptr_ecriture++;
ptr_lecture++;
}

(*ptr_ecriture) = d_code_fin_chaine;

if ((chaine = realloc(chaine, ((ptr_ecriture - chaine) + 1) *
sizeof(unsigned char))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}
}	}
else	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));
}	}
}	}
Line 1963 formateur(struct_processus *s_etat_proce	Line 1813 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 1998 formateur(struct_processus *s_etat_proce	Line 1848 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 2071 formateur(struct_processus *s_etat_proce	Line 1921 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 2132 formateur(struct_processus *s_etat_proce	Line 1982 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 2229 formateur(struct_processus *s_etat_proce	Line 2079 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 2337 formateur(struct_processus *s_etat_proce	Line 2187 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 2431 formateur(struct_processus *s_etat_proce	Line 2281 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 2539 formateur(struct_processus *s_etat_proce	Line 2389 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 2561 formateur(struct_processus *s_etat_proce	Line 2411 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 2572 formateur(struct_processus *s_etat_proce	Line 2422 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 2606 formateur(struct_processus *s_etat_proce	Line 2456 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 2617 formateur(struct_processus *s_etat_proce	Line 2467 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 2636 formateur(struct_processus *s_etat_proce	Line 2486 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 2671 formateur(struct_processus *s_etat_proce	Line 2522 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 2697 formateur(struct_processus *s_etat_proce	Line 2549 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 2773 formateur(struct_processus *s_etat_proce	Line 2625 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 2794 formateur(struct_processus *s_etat_proce	Line 2646 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 2804 formateur(struct_processus *s_etat_proce	Line 2656 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 2820 formateur(struct_processus *s_etat_proce	Line 2672 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 2830 formateur(struct_processus *s_etat_proce	Line 2682 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 2861 formateur(struct_processus *s_etat_proce	Line 2714 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 2887 formateur(struct_processus *s_etat_proce	Line 2741 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 2963 formateur(struct_processus *s_etat_proce	Line 2817 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 2984 formateur(struct_processus *s_etat_proce	Line 2838 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 2994 formateur(struct_processus *s_etat_proce	Line 2848 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 3028 formateur(struct_processus *s_etat_proce	Line 2882 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 3038 formateur(struct_processus *s_etat_proce	Line 2892 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 3056 formateur(struct_processus *s_etat_proce	Line 2910 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 3091 formateur(struct_processus *s_etat_proce	Line 2946 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 3117 formateur(struct_processus *s_etat_proce	Line 2973 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 3176 formateur(struct_processus *s_etat_proce	Line 3032 formateur(struct_processus *s_etat_proce
}	}
else if ((*s_objet).type == MTX)	else if ((*s_objet).type == MTX)
{	{
if (alsprintf(&chaine, "Mutex $ %016lX", (unsigned long)	if (alsprintf(s_etat_processus, &chaine,
&((((struct_mutex ) (*s_objet).objet)).mutex)) < 0)	"Mutex $ %016llX owned by $ %016llX",
	&((((struct_mutex ) (*s_objet).objet)).mutex),
	(logical8) (((struct_mutex ) (*s_objet).objet)).tid) < 0)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3228 formateur(struct_processus *s_etat_proce	Line 3086 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 3269 formateur(struct_processus *s_etat_proce	Line 3127 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 3336 formateur(struct_processus *s_etat_proce	Line 3194 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 3403 formateur(struct_processus *s_etat_proce	Line 3261 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 3440 formateur(struct_processus *s_etat_proce	Line 3298 formateur(struct_processus *s_etat_proce

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

	strcpy(chaine, chaine_sauvegarde);
	free(chaine_sauvegarde);
	strcat(chaine, " ]");
	}
	}
	else if ((*s_objet).type == REC)
	{
	chaine = (unsigned char ) malloc(4 sizeof(unsigned char));

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

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

	// L'objet se compose de deux tables à une dimension de
	// mêmes tailles.

	chaine_sauvegarde = chaine;

	if ((chaine_formatee = formateur(s_etat_processus, (long) offset,
	(((struct_record ) (*s_objet).objet)).noms)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee)
	+ strlen(chaine_sauvegarde) + 1)
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
	free(chaine_sauvegarde);
	free(chaine_formatee);

	if (test_cfsf(s_etat_processus, 45) == d_vrai)
	{
	chaine_sauvegarde = chaine;

	if ((chaine = (unsigned char *) malloc(
	(strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char)))
	== NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	strcpy(chaine, chaine_sauvegarde);
	free(chaine_sauvegarde);
	strcat(chaine, "\n");

	chaine_sauvegarde = chaine;

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

	if (chaine == NULL)
	{
(*s_etat_processus).erreur_systeme =	(*s_etat_processus).erreur_systeme =
d_es_allocation_memoire;	d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3447 formateur(struct_processus *s_etat_proce	Line 3376 formateur(struct_processus *s_etat_proce

strcpy(chaine, chaine_sauvegarde);	strcpy(chaine, chaine_sauvegarde);
free(chaine_sauvegarde);	free(chaine_sauvegarde);
strcat(chaine, " ]");	ptre = &(chaine[strlen(chaine)]);

	for(k = 0; k < offset; k++, *(ptre++) = ' ');

	(*ptre) = d_code_fin_chaine;
	}
	else
	{
	chaine_sauvegarde = chaine;

	if ((chaine = (unsigned char *) malloc(
	(strlen(chaine_sauvegarde) + 2)
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	strcpy(chaine, chaine_sauvegarde);
	free(chaine_sauvegarde);
	strcat(chaine, " ");
	}

	chaine_sauvegarde = chaine;

	if ((chaine_formatee = formateur(s_etat_processus, (long) offset,
	(((struct_record ) (*s_objet).objet)).donnees)) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	if ((chaine = (unsigned char *) malloc((strlen(chaine_formatee)
	+ strlen(chaine_sauvegarde) + 1)
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	sprintf(chaine, "%s%s", chaine_sauvegarde, chaine_formatee);
	free(chaine_sauvegarde);
	free(chaine_formatee);

	chaine_sauvegarde = chaine;
	chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4)
	* sizeof(unsigned char));

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

	strcpy(chaine, chaine_sauvegarde);
	free(chaine_sauvegarde);
	strcat(chaine, " ]\|");
	}
	else if ((*s_objet).type == NON)
	{
	if ((chaine = malloc((strlen("System object") + 1)
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
	return(NULL);
	}

	strcpy(chaine, "System object");
	}
	else if ((*s_objet).type == EXT)
	{
	l_element_courant = (*s_etat_processus).s_bibliotheques;

	while(l_element_courant != NULL)
	{
	if ((((struct_bibliotheque ) (*l_element_courant).donnee))
	.descripteur == (*s_objet).descripteur_bibliotheque)
	{
	if ((__type_disp = dlsym((*s_objet).descripteur_bibliotheque,
	"__type_disp")) == NULL)
	{
	// Symbole externe non affichable

	if ((chaine = malloc((strlen(
	"External symbol (disp function not found)") + 1)
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	strcpy(chaine, "External symbol (disp function not found)");
	}
	else
	{
	// Symbole externe affichable
	void **arg;

	arg = (void **) &s_objet;
	__type_disp(s_etat_processus, arg);
	chaine = (unsigned char ) (arg);
	}

	break;
	}

	l_element_courant = (*l_element_courant).suivant;
}	}

	if (l_element_courant == NULL)
	{
	// Symbole externe non affichable

	if ((chaine = malloc((strlen("External symbol") + 1)
	* sizeof(unsigned char))) == NULL)
	{
	(*s_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return(NULL);
	}

	strcpy(chaine, "External symbol");
	}
	}
	else
	{
	BUG(1, uprintf("Unknown symbol type\n"));
}	}

return(chaine);	return(chaine);
Line 3503 formateur_nombre(struct_processus *s_eta	Line 3560 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 3541 formateur_nombre(struct_processus *s_eta	Line 3598 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 3630 formateur_reel(struct_processus *s_etat_	Line 3687 formateur_reel(struct_processus *s_etat_
long correction;	long correction;
long dernier_chiffre_significatif;	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;

Line 3639 formateur_reel(struct_processus *s_etat_	Line 3698 formateur_reel(struct_processus *s_etat_
unsigned char *ptr;	unsigned char *ptr;
unsigned char tampon[32 + 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));

if (chaine == NULL)	if (chaine == NULL)
Line 3653 formateur_reel(struct_processus *s_etat_	Line 3709 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 3668 formateur_reel(struct_processus *s_etat_	Line 3748 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 3676 formateur_reel(struct_processus *s_etat_	Line 3756 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 3840 formateur_reel(struct_processus *s_etat_	Line 3929 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 3863 formateur_reel(struct_processus *s_etat_	Line 3952 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 3900 formateur_reel(struct_processus *s_etat_	Line 3989 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 3909 formateur_reel(struct_processus *s_etat_	Line 3998 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;
Line 3922 formateur_reel(struct_processus *s_etat_	Line 4011 formateur_reel(struct_processus *s_etat_

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.24.2.4
changed lines
	Added in v.1.93