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.13 and 1.65

version 1.13, 2010/06/24 10:10:40	version 1.65, 2013/09/06 10:30:51
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.17	RPL/2 (R) version 4.1.16
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

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

Line 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 67 formateur(struct_processus *s_etat_proce	Line 69 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 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 106 formateur(struct_processus *s_etat_proce	Line 103 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "@ %016lX", (((unsigned long )	if (alsprintf(&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 119 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "Library $ %016lX [%s]",	if (alsprintf(&chaine, "Library $ %016llX [%s]",
(unsigned long) (((struct_bibliotheque )	(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)
{	{
Line 140 formateur(struct_processus *s_etat_proce	Line 137 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "Semaphore $ %016lX '%s'",	if (alsprintf(&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)
{	{
Line 161 formateur(struct_processus *s_etat_proce	Line 158 formateur(struct_processus *s_etat_proce
"MYSQL") == 0)	"MYSQL") == 0)
{	{
# ifdef MYSQL_SUPPORT	# ifdef MYSQL_SUPPORT
if (alsprintf(&chaine, "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) < 0)	(((struct_connecteur_sql ) (*s_objet).objet)).type) < 0)
{	{
Line 188 formateur(struct_processus *s_etat_proce	Line 185 formateur(struct_processus *s_etat_proce
"POSTGRESQL") == 0)	"POSTGRESQL") == 0)
{	{
# ifdef POSTGRESQL_SUPPORT	# ifdef POSTGRESQL_SUPPORT
if (alsprintf(&chaine, "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) < 0)	(((struct_connecteur_sql ) (*s_objet).objet)).type) < 0)
{	{
Line 230 formateur(struct_processus *s_etat_proce	Line 227 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(&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 237 formateur(struct_processus *s_etat_proce
}	}
else	else
{	{
if (alsprintf(&chaine, "Light weight process $ %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) < 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 257 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "File $ %016lX", (unsigned long)	if (alsprintf(&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 392 formateur(struct_processus *s_etat_proce	Line 389 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if (alsprintf(&chaine, "Socket %016lX",	if (alsprintf(&chaine, "Socket $ %016llX", (unsigned long long)
(unsigned long) (((struct_socket )	(((struct_socket ) ((*s_objet).objet))).socket) < 0)
((*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 813 formateur(struct_processus *s_etat_proce	Line 809 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 943 formateur(struct_processus *s_etat_proce	Line 939 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 963 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 1044 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 1068 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 1326 formateur(struct_processus *s_etat_proce	Line 1322 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 1466 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 1486 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 1514 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 1576 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 1586 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 1598 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 1609 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 1631 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 1747 formateur(struct_processus *s_etat_proce
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
*/	*/

if ((chaine = malloc((strlen((unsigned char *)	if (((*s_etat_processus).autorisation_conversion_chaine == 'Y') &&
((s_objet).objet)) + 1) sizeof(unsigned char))) == NULL)	(test_cfsf(s_etat_processus, 34) == d_vrai))
{	{
(*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)

if ((*s_etat_processus).autorisation_conversion_chaine == 'Y')
{
ptr_lecture = (unsigned char ) (s_objet).objet;
ptr_ecriture = chaine;

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)) == '\\')
{
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, (strlen(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 1838 formateur(struct_processus *s_etat_proce	Line 1778 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 1873 formateur(struct_processus *s_etat_proce	Line 1813 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 1946 formateur(struct_processus *s_etat_proce	Line 1886 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 2007 formateur(struct_processus *s_etat_proce	Line 1947 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 2104 formateur(struct_processus *s_etat_proce	Line 2044 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 2212 formateur(struct_processus *s_etat_proce	Line 2152 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 2306 formateur(struct_processus *s_etat_proce	Line 2246 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 2414 formateur(struct_processus *s_etat_proce	Line 2354 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 2436 formateur(struct_processus *s_etat_proce	Line 2376 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 2447 formateur(struct_processus *s_etat_proce	Line 2387 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 2481 formateur(struct_processus *s_etat_proce	Line 2421 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 2492 formateur(struct_processus *s_etat_proce	Line 2432 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 2511 formateur(struct_processus *s_etat_proce	Line 2451 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 2546 formateur(struct_processus *s_etat_proce	Line 2487 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 2572 formateur(struct_processus *s_etat_proce	Line 2514 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 2648 formateur(struct_processus *s_etat_proce	Line 2590 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 2669 formateur(struct_processus *s_etat_proce	Line 2611 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 2679 formateur(struct_processus *s_etat_proce	Line 2621 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 2695 formateur(struct_processus *s_etat_proce	Line 2637 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 2705 formateur(struct_processus *s_etat_proce	Line 2647 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 2736 formateur(struct_processus *s_etat_proce	Line 2679 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 2762 formateur(struct_processus *s_etat_proce	Line 2706 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 2838 formateur(struct_processus *s_etat_proce	Line 2782 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 2859 formateur(struct_processus *s_etat_proce	Line 2803 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 2869 formateur(struct_processus *s_etat_proce	Line 2813 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 2903 formateur(struct_processus *s_etat_proce	Line 2847 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 2913 formateur(struct_processus *s_etat_proce	Line 2857 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 2931 formateur(struct_processus *s_etat_proce	Line 2875 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 2966 formateur(struct_processus *s_etat_proce	Line 2911 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 2992 formateur(struct_processus *s_etat_proce	Line 2938 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 3051 formateur(struct_processus *s_etat_proce	Line 2997 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(&chaine, "Mutex $ %016llX owned by $ %016llX",
&((((struct_mutex ) (*s_objet).objet)).mutex)) < 0)	&((((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 3103 formateur(struct_processus *s_etat_proce	Line 3050 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 3144 formateur(struct_processus *s_etat_proce	Line 3091 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 3211 formateur(struct_processus *s_etat_proce	Line 3158 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 3278 formateur(struct_processus *s_etat_proce	Line 3225 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 3378 formateur_nombre(struct_processus *s_eta	Line 3325 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 3416 formateur_nombre(struct_processus *s_eta	Line 3363 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 3505 formateur_reel(struct_processus *s_etat_	Line 3452 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 3514 formateur_reel(struct_processus *s_etat_	Line 3463 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 3528 formateur_reel(struct_processus *s_etat_	Line 3474 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 3543 formateur_reel(struct_processus *s_etat_	Line 3513 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 3551 formateur_reel(struct_processus *s_etat_	Line 3521 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 3715 formateur_reel(struct_processus *s_etat_	Line 3694 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 3738 formateur_reel(struct_processus *s_etat_	Line 3717 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 3758 formateur_reel(struct_processus *s_etat_	Line 3737 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 3768 formateur_reel(struct_processus *s_etat_	Line 3754 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 3777 formateur_reel(struct_processus *s_etat_	Line 3763 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 3790 formateur_reel(struct_processus *s_etat_	Line 3776 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.13
changed lines
	Added in v.1.65