/*
================================================================================
  RPL/2 (R) version 4.1.5
  Copyright (C) 1989-2011 Dr. BERTRAND Joël

  This file is part of RPL/2.

  RPL/2 is free software; you can redistribute it and/or modify it
  under the terms of the CeCILL V2 License as published by the french
  CEA, CNRS and INRIA.
 
  RPL/2 is distributed in the hope that it will be useful, but WITHOUT
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  FITNESS FOR A PARTICULAR PURPOSE.  See the CeCILL V2 License
  for more details.
 
  You should have received a copy of the CeCILL License
  along with RPL/2. If not, write to info@cecill.info.
================================================================================
*/


#include "rpl-conv.h"


/*
================================================================================
  Routine de formation des données pour l'écriture dans les fichiers
================================================================================
  Entrées : structure sur l'état du processus et objet à afficher
  Longueur est la précision requise et longueur_champ, le nombre maximal
  de caractères de la chaîne résultat (-1 signifiant une absence de contrainte)
  Type = 'F/U' (formaté, non formaté)
--------------------------------------------------------------------------------
  Sorties : chaine de caractères et longueur du tableau de caractères
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

unsigned char *
formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,
		struct_objet *s_format, long longueur, long longueur_champ,
		unsigned char format_sortie, unsigned char type,
		long *longueur_effective, long *recursivite)
{
	/*
	 * Traitement du format des fichiers formatés :
	 *
	 * { "standard*(*)" (format classique sans limitation)
	 *   "standard*(Y)" (format classique limité à Y caractères)
	 *   "fixed*X(*)"   (format virgule fixe avec une partie
	 *                   fractionnaire composée de X chiffres,
	 *                   mais dont la longueur est limité par
	 *                   la précision de la représentation interne)
	 *   "fixed*X(Y)"   (idem, mais longueur totale inférieure ou égale à
	 *                   Y caractères)
	 *   "scientific*X(*)"
	 *   "scientific*X(Y)"
	 *   "engineer*X(*)"
	 *   "engineer*X(Y)"
	 *   "binary*X(*)"
	 *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)
	 *   "character*(*)"
	 *   "character*(Y)" }
	 *
	 * Traitement du format des fichiers non formatés :
	 *
	 * { "integer*1", "integer*2", "integer*4", "integer*8",
	 *   "real*4", "real*8", ["real*16",]
	 *   "complex*8", "complex*16", ["complex*32",]
	 *   "logical*1", "logical*2", "logical*4", logical*8",
	 *   "character" }
	 */

	logical1					autorisation_parenthese;
	logical1					format_degenere;
	logical1					presence_signe;

	struct_liste_chainee		*l_atome;
	struct_liste_chainee		*l_element_courant;
	struct_liste_chainee		*l_element_courant_format;
	struct_liste_chainee		*l_liste1;
	struct_liste_chainee		*l_liste2;

	struct_objet				*s_sous_objet;
	struct_objet				*s_sous_objet_1;
	struct_objet				*s_sous_objet_2;
	struct_objet				*s_sous_objet_3;

	unsigned char				base[1 + 1];
	unsigned char				*chaine;
	unsigned char				*chaine_fonction;
	unsigned char				*chaine_formatee;
	unsigned char				*chaine_tampon;
	unsigned char				*chaine_sauvegarde;
	unsigned char				*format_chaine;
	unsigned char				*ptre;
	unsigned char				*ptrl;
	unsigned char				tampon[64 + 1];

	unsigned long				i;
	unsigned long				j;
	unsigned long				nombre_arguments;
	unsigned long				nombre_arguments_fonction;
	unsigned long				nombre_colonnes;
	unsigned long				nombre_elements;
	unsigned long				nombre_lignes;

	integer8					longueur_liste;
	integer8					longueur_totale;
	integer8					masque_binaire;
	integer8					position_1;
	integer8					position_2;
	integer8					position_3;

	(*recursivite)++;

	if (type == 'F')
	{
		/*
		 * Fichiers formatés
		 */

		chaine = NULL;
		chaine_formatee = NULL;
		chaine_sauvegarde = NULL;

		strcpy(base, " ");

		masque_binaire = 0;

		if ((*s_objet).type == ALG)
		{

/*
--------------------------------------------------------------------------------
  Expression algébrique
--------------------------------------------------------------------------------
*/

			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;

			while(l_element_courant != NULL)
			{
				if ((*(*l_element_courant).donnee).type == FCT)
				{
					if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
							.donnee).objet)).nom_fonction, "<<") != 0) &&
							(strcmp((*((struct_fonction *)
							(*(*l_element_courant)
							.donnee).objet)).nom_fonction, ">>") != 0))
					{
						if ((strcmp((*((struct_fonction *)
								(*(*l_element_courant)
								.donnee).objet)).nom_fonction, "+") == 0) ||
								(strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction, "-") == 0) || (strcmp(
								(*((struct_fonction *) (*(*l_element_courant)
								.donnee).objet)).nom_fonction, "*") == 0) ||
								(strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"/") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"^") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"<") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								">") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"==") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"<>") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"<=") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"=<") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								">=") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"=>") == 0))
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_2) == d_erreur)
							{
								return(NULL);
							}

							chaine_sauvegarde = (*s_etat_processus)
									.instruction_courante;

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

							sprintf((*s_etat_processus).instruction_courante,
									"'%s'", (unsigned char *)
									(*s_sous_objet_2).objet);

							presence_signe = (((*s_etat_processus)
									.instruction_courante[1] == '+')
									|| ((*s_etat_processus)
									.instruction_courante[1]
									== '-')) ? d_vrai : d_faux;

							recherche_type(s_etat_processus);

							if ((*s_etat_processus).erreur_execution != d_ex)
							{
								// Aucune erreur ne peut être renvoyée.

								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_3) == d_erreur)
							{
								return(NULL);
							}

							free((*s_etat_processus).instruction_courante);

							(*s_etat_processus).instruction_courante =
									chaine_sauvegarde;

							autorisation_parenthese = d_faux;

							if ((*s_sous_objet_3).type == ALG)
							{
								l_atome = (struct_liste_chainee *)
										(*s_sous_objet_3).objet;
								chaine_fonction = "";
								nombre_arguments_fonction = 0;

								while(l_atome != NULL)
								{
									if ((*(*l_atome).donnee).type == FCT)
									{
										if (strcmp((*((struct_fonction *)
												(*(*l_atome).donnee).objet))
												.nom_fonction, ">>") != 0)
										{
											chaine_fonction =
													(*((struct_fonction *)
													(*(*l_atome).donnee).objet))
													.nom_fonction;
											nombre_arguments_fonction =
													(*((struct_fonction *)
													(*(*l_atome).donnee).objet))
													.nombre_arguments;
										}
									}

									l_atome = (*l_atome).suivant;
								}

								if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "+") == 0)
								{
									if ((strcmp(chaine_fonction, "AND") == 0) ||
											(strcmp(chaine_fonction, "XOR") ==
											0) || (strcmp(chaine_fonction, "OR")
											== 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "-") == 0)
								{
									if (nombre_arguments_fonction != 0)
									{
										autorisation_parenthese = d_faux;
									}
									else
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "*") == 0)
								{
									if ((strcmp(chaine_fonction, "+") == 0) ||
											(strcmp(chaine_fonction, "-") == 0)
											|| (strcmp(chaine_fonction, "AND")
											== 0) || (strcmp(chaine_fonction,
											"XOR") == 0) || (strcmp(
											chaine_fonction, "OR") == 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "/") == 0)
								{
									if (nombre_arguments_fonction != 0)
									{
										autorisation_parenthese = d_faux;
									}
									else
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "^") == 0))
								{
									if (nombre_arguments_fonction != 0)
									{
										autorisation_parenthese = d_faux;
									}
									else
									{
										autorisation_parenthese = d_vrai;
									}
								}
							}

							if ((autorisation_parenthese == d_vrai) ||
									(presence_signe == d_vrai))
							{
								chaine_sauvegarde = (unsigned char *)
										(*s_sous_objet_2).objet;

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

								sprintf((unsigned char *) (*s_sous_objet_2)
										.objet, "(%s)", chaine_sauvegarde);
								free(chaine_sauvegarde);
							}

							liberation(s_etat_processus, s_sous_objet_3);

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							chaine_sauvegarde = (*s_etat_processus)
									.instruction_courante;

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

							sprintf((*s_etat_processus).instruction_courante,
									"'%s'", (unsigned char *)
									(*s_sous_objet_1).objet);

							recherche_type(s_etat_processus);

							if ((*s_etat_processus).erreur_execution != d_ex)
							{
								// Aucune erreur ne peut être renvoyée.

								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_3) == d_erreur)
							{
								return(NULL);
							}

							free((*s_etat_processus).instruction_courante);

							(*s_etat_processus).instruction_courante =
									chaine_sauvegarde;

							autorisation_parenthese = d_faux;

							if ((*s_sous_objet_3).type == ALG)
							{
								l_atome = (struct_liste_chainee *)
										(*s_sous_objet_3).objet;
								chaine_fonction = "";

								while(l_atome != NULL)
								{
									if ((*(*l_atome).donnee).type == FCT)
									{
										if (strcmp((*((struct_fonction *)
												(*(*l_atome).donnee).objet))
												.nom_fonction, ">>") != 0)
										{
											chaine_fonction =
													(*((struct_fonction *)
													(*(*l_atome).donnee).objet))
													.nom_fonction;
										}
									}

									l_atome = (*l_atome).suivant;
								}

								if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "+") == 0) ||
										(strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "-") == 0))
								{
									if ((strcmp(chaine_fonction, "AND") == 0) ||
											(strcmp(chaine_fonction, "XOR") ==
											0) || (strcmp(chaine_fonction, "OR")
											== 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "*") == 0) ||
										(strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "/") == 0))
								{
									if ((strcmp(chaine_fonction, "+") == 0) ||
											(strcmp(chaine_fonction, "-") == 0)
											|| (strcmp(chaine_fonction, "AND")
											== 0) || (strcmp(chaine_fonction,
											"XOR") == 0) || (strcmp(
											chaine_fonction, "OR") == 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "^") == 0))
								{
									autorisation_parenthese = d_vrai;
								}
							}

							if (autorisation_parenthese == d_vrai)
							{
								chaine_sauvegarde = (unsigned char *)
										(*s_sous_objet_1).objet;

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

								sprintf((unsigned char *) (*s_sous_objet_1)
										.objet, "(%s)", chaine_sauvegarde);
								free(chaine_sauvegarde);
							}

							liberation(s_etat_processus, s_sous_objet_3);

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							if (((*s_sous_objet).objet = (void *)
									malloc((strlen(
									(unsigned char *) (*s_sous_objet_1).objet) +
									strlen((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction) + strlen((unsigned char *)
									(*s_sous_objet_2).objet) + 1) *
									sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"%s%s%s", (unsigned char *)
									(*s_sous_objet_1)
									.objet, (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, (unsigned char *)
									(*s_sous_objet_2).objet);

							liberation(s_etat_processus, s_sous_objet_1);
							liberation(s_etat_processus, s_sous_objet_2);

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else if (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction, "=") == 0)
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									&s_sous_objet_2) == d_erreur)
							{
								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									&s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							autorisation_parenthese = d_vrai;
							l_atome = l_element_courant;

							if (l_atome != NULL)
							{
								if ((*l_atome).suivant != NULL)
								{
									l_atome = (*l_atome).suivant;

									if ((*(*l_atome).donnee).type == FCT)
									{
										if (strcmp((*((struct_fonction *)
												(*(*l_atome).donnee).objet))
												.nom_fonction, ">>") == 0)
										{
											if ((*l_atome).suivant == NULL)
											{
												autorisation_parenthese =
														d_faux;
											}
										}
									}
								}
							}

							if (autorisation_parenthese == d_vrai)
							{
								if (((*s_sous_objet).objet =
										(void *) malloc((strlen(
										(unsigned char *) (*s_sous_objet_1)
										.objet) + strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) +
										strlen((unsigned char *)
										(*s_sous_objet_2).objet) + 2 + 1) *
										sizeof(unsigned char))) == NULL)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_allocation_memoire;
									return(NULL);
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"(%s%s%s)", (unsigned char *)
										(*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}
							else
							{
								if (((*s_sous_objet).objet =
										(void *) malloc((strlen(
										(unsigned char *) (*s_sous_objet_1)
										.objet) + strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) + strlen(
										(unsigned char *) (*s_sous_objet_2)
										.objet) + 1) * sizeof(unsigned char)))
										== NULL)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_allocation_memoire;
									return(NULL);
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"%s%s%s", (unsigned char *)
										(*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}

							liberation(s_etat_processus, s_sous_objet_1);
							liberation(s_etat_processus, s_sous_objet_2);

							if (empilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else if (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"NOT") == 0)
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							if (((*s_sous_objet).objet = (unsigned char *)
									malloc(
									(strlen((unsigned char *) (*s_sous_objet_1)
									.objet) + 4 + 1) * sizeof(unsigned char)))
									== NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"%s %s", (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, (unsigned char *)
									(*s_sous_objet_1).objet );

							liberation(s_etat_processus, s_sous_objet_1);

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else if ((strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"OR") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"XOR") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"AND") == 0))
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_2) == d_erreur)
							{
								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							if (((*s_sous_objet).objet = (void *)
									malloc((strlen(
									(unsigned char *) (*s_sous_objet_1).objet) +
									strlen((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction) + strlen((unsigned char *)
									(*s_sous_objet_2).objet) + 2 + 1) *
									sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"%s %s %s", (unsigned char *)
									(*s_sous_objet_1)
									.objet, (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, (unsigned char *)
									(*s_sous_objet_2).objet);

							liberation(s_etat_processus, s_sous_objet_1);
							liberation(s_etat_processus, s_sous_objet_2);

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else
						{
							nombre_arguments = (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nombre_arguments;

							if ((chaine = (unsigned char *)
									malloc(sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}
							
							chaine[0] = d_code_fin_chaine;

							for(i = 0; i < nombre_arguments; i++)
							{
								if ((nombre_arguments - i) > 1)
								{
									l_liste1 = (*s_etat_processus).l_base_pile;

									for(j = 2; j < (nombre_arguments - i); j++)
									{
										l_liste1 = (*l_liste1).suivant;
									}

									l_liste2 = (*l_liste1).suivant;
									(*l_liste1).suivant = (*l_liste2).suivant;
									(*l_liste2).suivant = (*s_etat_processus)
											.l_base_pile;
									(*s_etat_processus).l_base_pile = l_liste2;
								}
								
								if (depilement(s_etat_processus,
										&((*s_etat_processus).l_base_pile),
										&s_sous_objet) == d_erreur)
								{
									return(NULL);
								}

								chaine_sauvegarde = chaine;

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

									sprintf(chaine, "%s", (unsigned char *)
											(*s_sous_objet).objet);
								}
								else
								{
									if ((chaine = (unsigned char *)
											malloc((strlen(chaine_sauvegarde)
											+ 1 + strlen((unsigned char *)
											(*s_sous_objet).objet) + 1) *
											sizeof(unsigned char))) == NULL)
									{
										(*s_etat_processus).erreur_systeme =
												d_es_allocation_memoire;
										return(NULL);
									}

									sprintf(chaine, "%s,%s", chaine_sauvegarde,
											(unsigned char *) (*s_sous_objet)
											.objet);
								}

								free(chaine_sauvegarde);
								liberation(s_etat_processus, s_sous_objet);
							}

							chaine_sauvegarde = chaine;

							if ((chaine = (unsigned char *) malloc((strlen(
									(*((struct_fonction *)
									(*(*l_element_courant)
									.donnee).objet)).nom_fonction) + 2 +
									strlen(chaine_sauvegarde) + 1) *
									sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf(chaine, "%s(%s)", (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, chaine_sauvegarde);
							free(chaine_sauvegarde);

							if ((s_sous_objet = allocation(s_etat_processus,
											CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

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

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
					}
				}
				else
				{
					if ((s_sous_objet = allocation(s_etat_processus, CHN))
							== NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					if (((*s_sous_objet).objet = (void *) formateur_fichier(
							s_etat_processus, (*l_element_courant).donnee,
							s_format, longueur, longueur_champ, format_sortie,
							type, longueur_effective, recursivite)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					if (((*(*l_element_courant).donnee).type == ALG)
							|| ((*(*l_element_courant).donnee).type == NOM))
					{
						chaine_sauvegarde = (unsigned char *)
								(*s_sous_objet).objet;

						if (((*s_sous_objet).objet = malloc((strlen(
								chaine_sauvegarde) - 1) *
								sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						ptrl = chaine_sauvegarde;
						ptre = (unsigned char *) (*s_sous_objet).objet;

						for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
								i--, *ptre++ = *ptrl++);

						(*ptre) = d_code_fin_chaine;

						free(chaine_sauvegarde);
					}
					else if ((*(*l_element_courant).donnee).type == CHN)
					{
						chaine_sauvegarde = (unsigned char *)
								(*s_sous_objet).objet;

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

						sprintf((unsigned char *) (*s_sous_objet).objet,
								"\"%s\"", chaine_sauvegarde);

						free(chaine_sauvegarde);
					}

					if (empilement(s_etat_processus, &((*s_etat_processus)
							.l_base_pile), s_sous_objet) == d_erreur)
					{
						return(NULL);
					}
				}

				l_element_courant = (*l_element_courant).suivant;
			}

			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					&s_sous_objet) == d_erreur)
			{
				return(NULL);
			}

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

			sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
			liberation(s_etat_processus, s_sous_objet);
		}
		else if ((*s_objet).type == BIN)
		{

/*
--------------------------------------------------------------------------------
  Entier binaire en base 2, 8, 10 ou 16
--------------------------------------------------------------------------------
*/

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

			masque_binaire = masque_entiers_binaires(s_etat_processus);

			if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
					(test_cfsf(s_etat_processus, 44) == d_faux))
			{

/*
-- Base décimale ---------------------------------------------------------------
*/

				sprintf(tampon, "%llu", (*((logical8 *)
						((*s_objet).objet))) & masque_binaire);
				strcpy(base, "d");
			}
			else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
					(test_cfsf(s_etat_processus, 44) == d_faux))
			{

/*
-- Base octale -----------------------------------------------------------------
*/

				sprintf(tampon, "%llo", (*((logical8 *)
						((*s_objet).objet))) & masque_binaire);
				strcpy(base, "o");
			}
			else if (test_cfsf(s_etat_processus, 44) == d_vrai)
			{

/*
-- Bases hexadécimale et binaire -----------------------------------------------
*/

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

				if (test_cfsf(s_etat_processus, 43) == d_vrai)
				{
					strcpy(base, "h");
				}
				else
				{
					chaine = (unsigned char *) malloc((strlen(tampon) + 1)
							* sizeof(unsigned char));

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

					strcpy(chaine, tampon);
					tampon[0] = 0;

					for(i = 0; i < strlen(chaine); i++)
					{
						switch(chaine[i])
						{
							case '0' :
							{
								strcat(tampon, (i != 0) ? "0000" : "0");
								break;
							}
							case '1' :
							{
									strcat(tampon, (i != 0) ? "0001" : "1");
								break;
							}
							case '2' :
							{
								strcat(tampon, (i != 0) ? "0010" : "10");
								break;
							}
							case '3' :
							{
								strcat(tampon, (i != 0) ? "0011" : "11");
								break;
							}
							case '4' :
							{
								strcat(tampon, (i != 0) ? "0100" : "100");
								break;
							}
							case '5' :
							{
								strcat(tampon, (i != 0) ? "0101" : "101");
								break;
							}
							case '6' :
							{
								strcat(tampon, (i != 0) ? "0110" : "110");
								break;
							}
							case '7' :
							{
								strcat(tampon, (i != 0) ? "0111" : "111");
								break;
							}
							case '8' :
							{
								strcat(tampon, "1000");
								break;
							}
							case '9' :
							{
								strcat(tampon, "1001");
								break;
							}
							case 'A' :
							{
								strcat(tampon, "1010");
								break;
							}
							case 'B' :
							{
								strcat(tampon, "1011");
								break;
							}
							case 'C' :
							{
								strcat(tampon, "1100");
								break;
							}
							case 'D' :
							{
								strcat(tampon, "1101");
								break;
							}
							case 'E' :
							{
								strcat(tampon, "1110");
								break;
							}
							case 'F' :
							{
								strcat(tampon, "1111");
								break;
							}
						}
					}

					free(chaine);
					strcpy(base, "b");
				}
			}

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

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

			strcpy(chaine, "# ");

			strcat(chaine, tampon);
			strcat(chaine, base);
		}
		else if ((*s_objet).type == CHN)
		{

/*
--------------------------------------------------------------------------------
  Chaîne de caractères
--------------------------------------------------------------------------------
*/

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

			if ((longueur_champ == -1) || (((long) strlen((unsigned char *)
					(*s_objet).objet)) < longueur_champ))
			{
				chaine = (unsigned char *) malloc((strlen((unsigned char *)
						((*s_objet).objet)) + 1) * sizeof(unsigned char));

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

				strcpy(chaine, (unsigned char *) ((*s_objet).objet));
			}
			else
			{
				chaine = (unsigned char *) malloc((longueur_champ + 1)
						* sizeof(unsigned char));

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

				strncpy(chaine, (unsigned char *) ((*s_objet).objet),
						longueur_champ);
				chaine[longueur_champ] = d_code_fin_chaine;
			}
		}
		else if ((*s_objet).type == CPL)
		{

/*
--------------------------------------------------------------------------------
  Complexe
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
					(void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C',
					longueur, longueur_champ, format_sortie)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(NULL);
			}

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

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

			strcpy(chaine, chaine_formatee);
			free(chaine_formatee);
		}
		else if ((*s_objet).type == RPN)
		{

/*
--------------------------------------------------------------------------------
  Définition
--------------------------------------------------------------------------------
*/

			l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
			chaine_sauvegarde = chaine;

			while(l_element_courant != NULL)
			{
				if ((chaine_formatee = formateur_fichier(s_etat_processus,
						(*l_element_courant).donnee, s_format,
						longueur, longueur_champ, format_sortie, type,
						longueur_effective, recursivite)) == NULL)
				{
					return(NULL);
				}

				if ((*(*l_element_courant).donnee).type == CHN)
				{
					chaine_tampon = chaine_formatee;

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

					sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
					free(chaine_tampon);
				}

				l_element_courant = (*l_element_courant).suivant;

				if (chaine != NULL)
				{
					chaine_sauvegarde = chaine;

					if ((chaine = (unsigned char *) malloc((strlen(
							chaine_sauvegarde) + strlen(chaine_formatee) + 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}
				else
				{
					chaine = chaine_formatee;
				}
			}

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

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

			chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
			strcpy(chaine, chaine_sauvegarde);
			free(chaine_sauvegarde);
		}
		else if ((*s_objet).type == INT)
		{

/*
--------------------------------------------------------------------------------
  Entier
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
					(void *) ((integer8 *) ((*s_objet).objet)), 'I',
					longueur, longueur_champ, format_sortie)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(NULL);
			}

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

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

			strcpy(chaine, chaine_formatee);
			free(chaine_formatee);
		}
		else if ((*s_objet).type == FCT)
		{

/*
--------------------------------------------------------------------------------
  Fonction
--------------------------------------------------------------------------------
*/

			chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
					((*s_objet).objet))).nom_fonction) + 1) *
					sizeof(unsigned char));

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

			strcpy(chaine, (unsigned char *) (*((struct_fonction *)
					((*s_objet).objet))).nom_fonction);
		}
		else if ((*s_objet).type == LST)
		{

/*
--------------------------------------------------------------------------------
  Liste
--------------------------------------------------------------------------------
*/

			chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));

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

			strcpy(chaine, "{");

			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
			l_element_courant_format = (struct_liste_chainee *)
					(*s_format).objet;
			nombre_elements = 0;

			while((l_element_courant != NULL) &&
					(l_element_courant_format != NULL))
			{
				if ((((*(*l_element_courant_format).donnee).type == LST)
						&& ((*(*l_element_courant).donnee).type == LST)) ||
						(((*(*l_element_courant_format).donnee).type == TBL)
						&& ((*(*l_element_courant).donnee).type == TBL)))
				{
					chaine_sauvegarde = chaine;

					if ((chaine_formatee = formateur_fichier(s_etat_processus,
							(*l_element_courant).donnee,
							(*l_element_courant_format).donnee,
							0, 0, ' ', 'F', longueur_effective, recursivite))
							== NULL)
					{
						return(NULL);
					}

					chaine = (unsigned char *) malloc((strlen(chaine_formatee)
							+ strlen(chaine_sauvegarde) + 2)
							* 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}
				else if ((*(*l_element_courant_format).donnee).type != CHN)
				{
					free(chaine);

					(*s_etat_processus).erreur_execution =
							d_ex_erreur_format_fichier;
					return(NULL);
				}
				else
				{
					if ((format_chaine = conversion_majuscule((unsigned char *)
							(*(*l_element_courant_format).donnee).objet))
							== NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					format_degenere = d_faux;

					if (strncmp("STANDARD*", format_chaine, 9) == 0)
					{
						format_sortie = 'S';
						position_1 = 9;
						format_degenere = d_vrai;
					}
					else if (strncmp("BINARY*", format_chaine, 7) == 0)
					{
						format_sortie = 'B';
						position_1 = 7;
					}
					else if (strncmp("FIXED*", format_chaine, 6) == 0)
					{
						format_sortie = 'F';
						position_1 = 6;
					}
					else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
					{
						format_sortie = 'I';
						position_1 = 11;
					}
					else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
					{
						format_sortie = 'E';
						position_1 = 9;
					}
					else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
					{
						format_sortie = 'C';
						position_1 = 10;
						format_degenere = d_vrai;
					}
					else
					{
						free(chaine);
						free(format_chaine);

						(*s_etat_processus).erreur_execution =
								d_ex_erreur_format_fichier;
						return(NULL);
					}

					position_3 = strlen(format_chaine);
					format_chaine[--position_3] = d_code_fin_chaine;

					position_2 = position_1;

					while(format_chaine[position_2] != '(')
					{
						if (format_chaine[position_2] == d_code_fin_chaine)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}

						position_2++;
					}

					format_chaine[position_2++] = d_code_fin_chaine;

					if (format_degenere == d_faux)
					{
						if (sscanf(&(format_chaine[position_1]), "%ld",
								&longueur) != 1)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}
					}
					else
					{
						longueur = -1;
					}

					if (strcmp(&(format_chaine[position_2]), "*") != 0)
					{
						if (sscanf(&(format_chaine[position_2]), "%ld",
								&longueur_champ) != 1)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}
					}
					else
					{
						longueur_champ = -1;
					}

					if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
							longueur_champ))
					{
						free(chaine);
						free(format_chaine);

						(*s_etat_processus).erreur_execution =
								d_ex_erreur_format_fichier;
						return(NULL);
					}

					free(format_chaine);
				
					chaine_sauvegarde = chaine;

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

					if ((*(*l_element_courant).donnee).type == CHN)
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ 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, " \"");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
						strcat(chaine, "\"");
					}
					else if ((*(*l_element_courant).donnee).type == NOM)
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ strlen(chaine_sauvegarde) + 2)
								* sizeof(unsigned char));

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

						sprintf(chaine, "%s %s", chaine_sauvegarde,
								chaine_formatee);
						free(chaine_formatee);
					}
					else
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ strlen(chaine_sauvegarde) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
					}
				}

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

			if ((l_element_courant != NULL) ||
					(l_element_courant_format != NULL))
			{
				free(chaine);

				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			chaine_sauvegarde = chaine;
			chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 3)
					* 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 == TBL)
		{

/*
--------------------------------------------------------------------------------
  Table
--------------------------------------------------------------------------------
*/

			if ((*s_format).type != TBL)
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
			l_element_courant_format = (struct_liste_chainee *)
					(*s_format).objet;

			if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
					(*((struct_tableau *) (*s_format).objet)).nombre_elements)
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

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

			strcpy(chaine, "<[");

			for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
					.nombre_elements; i++)
			{
				if ((((*(*((struct_tableau *) (*s_format).objet))
						.elements[i]).type == LST) &&
						((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
						.type == LST)) ||
						(((*(*((struct_tableau *) (*s_format).objet))
						.elements[i]).type == TBL) &&
						((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
						.type == TBL)))
				{
					chaine_sauvegarde = chaine;

					if ((chaine_formatee = formateur_fichier(s_etat_processus,
							(*l_element_courant).donnee,
							(*l_element_courant_format).donnee,
							0, 0, ' ', 'F', longueur_effective, recursivite))
							== NULL)
					{
						return(NULL);
					}

					chaine = (unsigned char *) malloc((strlen(chaine_formatee)
							+ strlen(chaine_sauvegarde) + 2)
							* 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}
				else if ((*(*((struct_tableau *) (*s_format).objet))
						.elements[i]).type != CHN)
				{
					free(chaine);

					(*s_etat_processus).erreur_execution =
							d_ex_erreur_format_fichier;
					return(NULL);
				}
				else
				{
					if ((format_chaine = conversion_majuscule((unsigned char *)
							(*(*((struct_tableau *) (*s_format).objet))
							.elements[i]).objet)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					format_degenere = d_faux;

					if (strncmp("STANDARD*", format_chaine, 9) == 0)
					{
						format_sortie = 'S';
						position_1 = 9;
						format_degenere = d_vrai;
					}
					else if (strncmp("BINARY*", format_chaine, 7) == 0)
					{
						format_sortie = 'B';
						position_1 = 7;
					}
					else if (strncmp("FIXED*", format_chaine, 6) == 0)
					{
						format_sortie = 'F';
						position_1 = 6;
					}
					else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
					{
						format_sortie = 'I';
						position_1 = 11;
					}
					else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
					{
						format_sortie = 'E';
						position_1 = 9;
					}
					else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
					{
						format_sortie = 'C';
						position_1 = 10;
						format_degenere = d_vrai;
					}
					else
					{
						free(chaine);
						free(format_chaine);

						(*s_etat_processus).erreur_execution =
								d_ex_erreur_format_fichier;
						return(NULL);
					}

					position_3 = strlen(format_chaine);
					format_chaine[--position_3] = d_code_fin_chaine;

					position_2 = position_1;

					while(format_chaine[position_2] != '(')
					{
						if (format_chaine[position_2] == d_code_fin_chaine)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}

						position_2++;
					}

					format_chaine[position_2++] = d_code_fin_chaine;

					if (format_degenere == d_faux)
					{
						if (sscanf(&(format_chaine[position_1]), "%ld",
								&longueur) != 1)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}
					}
					else
					{
						longueur = -1;
					}

					if (strcmp(&(format_chaine[position_2]), "*") != 0)
					{
						if (sscanf(&(format_chaine[position_2]), "%ld",
								&longueur_champ) != 1)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}
					}
					else
					{
						longueur_champ = -1;
					}

					if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
							longueur_champ))
					{
						free(chaine);
						free(format_chaine);

						(*s_etat_processus).erreur_execution =
								d_ex_erreur_format_fichier;
						return(NULL);
					}

					free(format_chaine);
				
					chaine_sauvegarde = chaine;

					if ((chaine_formatee = formateur_fichier(s_etat_processus,
							(*((struct_tableau *) (*s_objet).objet))
							.elements[i], s_format,
							longueur, longueur_champ, format_sortie, type,
							longueur_effective, recursivite)) == NULL)
					{
						return(NULL);
					}

					if ((*(*((struct_tableau *) (*s_objet).objet))
							.elements[i]).type == CHN)
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ 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, " \"");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
						strcat(chaine, "\"");
					}
					else if ((*(*((struct_tableau *) (*s_objet).objet))
							.elements[i]).type == NOM)
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ strlen(chaine_sauvegarde) + 2)
								* sizeof(unsigned char));

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

						sprintf(chaine, "%s %s", chaine_sauvegarde,
								chaine_formatee);
						free(chaine_formatee);
					}
					else
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ strlen(chaine_sauvegarde) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						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 == MCX)
		{

/*
--------------------------------------------------------------------------------
  Matrice complexe
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_lignes;
			nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_colonnes;

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[[");

				for(i = 0; i < nombre_lignes; i++)
				{
					for(j = 0; j < nombre_colonnes; j++)
					{
						if ((chaine_formatee =
								formateur_fichier_nombre(s_etat_processus,
								(void *) &(((struct_complexe16 **)
								((*((struct_matrice *)
								((*s_objet).objet))).tableau))[i][j]), 'C',
								longueur, longueur_champ, format_sortie))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine_sauvegarde = chaine;
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) +
								strlen(chaine_formatee) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
					}

					chaine_sauvegarde = chaine;
					if (test_cfsf(s_etat_processus, 45) == d_vrai)
					{
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) + 6)
								* 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, " ]\n [");
					}
					else
					{
						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, " ][");
					}
				}

				if (test_cfsf(s_etat_processus, 45) == d_vrai)
				{
					chaine[strlen(chaine) - 3] = ']';
					chaine[strlen(chaine) - 2] = 0;

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

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

					strcpy(chaine, chaine_sauvegarde);
					free(chaine_sauvegarde);
				}
				else
				{
					chaine[strlen(chaine) - 2] = ']';
					chaine[strlen(chaine) - 1] = 0;

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
							+ 2) * 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 == MIN)
		{

/*
--------------------------------------------------------------------------------
  Matrice entière
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_lignes;
			nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_colonnes;

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[[");

				for(i = 0; i < nombre_lignes; i++)
				{
					for(j = 0; j < nombre_colonnes; j++)
					{
						if ((chaine_formatee =
								formateur_fichier_nombre(s_etat_processus,
								(void *) &(((integer8 **) ((*((struct_matrice *)
								((*s_objet).objet))).tableau))[i][j]), 'I',
								longueur, longueur_champ, format_sortie))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine_sauvegarde = chaine;
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) +
								strlen(chaine_formatee) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
					}

					chaine_sauvegarde = chaine;
					if (test_cfsf(s_etat_processus, 45) == d_vrai)
					{
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) + 6)
								* 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, " ]\n [");
					}
					else
					{
						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, " ][");
					}
				}

				if (test_cfsf(s_etat_processus, 45) == d_vrai)
				{
					chaine[strlen(chaine) - 3] = ']';
					chaine[strlen(chaine) - 2] = 0;

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

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

					strcpy(chaine, chaine_sauvegarde);
					free(chaine_sauvegarde);
				}
				else
				{
					chaine[strlen(chaine) - 2] = ']';
					chaine[strlen(chaine) - 1] = 0;

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
							+ 2) * 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 == MRL)
		{

/*
--------------------------------------------------------------------------------
  Matrice réelle
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_lignes;
			nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_colonnes;

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[[");

				for(i = 0; i < nombre_lignes; i++)
				{
					for(j = 0; j < nombre_colonnes; j++)
					{
						if ((chaine_formatee =
								formateur_fichier_nombre(s_etat_processus,
								(void *) &(((real8 **) ((*((struct_matrice *)
								((*s_objet).objet))).tableau))[i][j]), 'R',
								longueur, longueur_champ, format_sortie))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine_sauvegarde = chaine;
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) +
								strlen(chaine_formatee) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
					}

					chaine_sauvegarde = chaine;
					if (test_cfsf(s_etat_processus, 45) == d_vrai)
					{
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) + 6)
								* 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, " ]\n [");
					}
					else
					{
						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, " ][");
					}
				}

				if (test_cfsf(s_etat_processus, 45) == d_vrai)
				{
					chaine[strlen(chaine) - 3] = ']';
					chaine[strlen(chaine) - 2] = 0;

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

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

					strcpy(chaine, chaine_sauvegarde);
					free(chaine_sauvegarde);
				}
				else
				{
					chaine[strlen(chaine) - 2] = ']';
					chaine[strlen(chaine) - 1] = 0;

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
							+ 2) * 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 == NOM)
		{

/*
--------------------------------------------------------------------------------
  Nom
--------------------------------------------------------------------------------
*/

			chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
					(*s_objet).objet)).nom) + 3) * sizeof(unsigned char));

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

			sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
		}
		else if ((*s_objet).type == REL)
		{

/*
--------------------------------------------------------------------------------
  Réel
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,
					(void *) ((real8 *) ((*s_objet).objet)), 'R',
					longueur, longueur_champ, format_sortie)) == NULL)
			{
				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
				return(NULL);
			}

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

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

			strcpy(chaine, chaine_formatee);
			free(chaine_formatee);
		}
		else if ((*s_objet).type == VCX)
		{

/*
--------------------------------------------------------------------------------
  Vecteur complexe
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

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

			chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[");

				for(i = 0; i < nombre_colonnes; i++)
				{
					if ((chaine_formatee =
							formateur_fichier_nombre(s_etat_processus,
							(void *) &(((struct_complexe16 *)
							((*((struct_vecteur *)
							((*s_objet).objet))).tableau))[i]), 'C',
							longueur, longueur_champ, format_sortie)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc(
							(strlen(chaine_sauvegarde) + strlen(chaine_formatee)
							+ 2) * 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}

				chaine_sauvegarde = chaine;
				chaine = (unsigned char *) malloc(
						(strlen(chaine_sauvegarde) + 3)
						* 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 == VIN)
		{

/*
--------------------------------------------------------------------------------
  Vecteur entier
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

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

			chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[");

				for(i = 0; i < nombre_colonnes; i++)
				{
					if ((chaine_formatee =
							formateur_fichier_nombre(s_etat_processus,
							(void *) &(((integer8 *) ((*((struct_vecteur *)
							((*s_objet).objet))).tableau))[i]), 'I',
							longueur, longueur_champ, format_sortie)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc(
							(strlen(chaine_sauvegarde) + strlen(chaine_formatee)
							+ 2) * 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}

				chaine_sauvegarde = chaine;
				chaine = (unsigned char *) malloc(
						(strlen(chaine_sauvegarde) + 3)
						* 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 == VRL)
		{

/*
--------------------------------------------------------------------------------
  Vecteur réel
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

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

			chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[");

				for(i = 0; i < nombre_colonnes; i++)
				{
					if ((chaine_formatee =
							formateur_fichier_nombre(s_etat_processus,
							(void *) &(((real8 *) ((*((struct_vecteur *)
							((*s_objet).objet))).tableau))[i]), 'R',
							longueur, longueur_champ, format_sortie)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc(
							(strlen(chaine_sauvegarde) + strlen(chaine_formatee)
							+ 2) * 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}

				chaine_sauvegarde = chaine;
				chaine = (unsigned char *) malloc(
						(strlen(chaine_sauvegarde) + 3)
						* 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
		{
			// Type non exportable

			(*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
			free(chaine);

			return(NULL);
		}

		(*longueur_effective) = strlen(chaine) + 1;
	}
	else
	{
		/*
		 * Fichiers non formatés
		 */

#define __zone() \
		do { int _i; \
			for(_i = 0; _i < longueur_totale; _i++) \
				printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)

		/*
		 * Chaque enregistrement est composé d'une donnée (une liste)
		 * suivie de sa longueur en octets et d'un champ binaire indiquant
		 * le format (integer*1,2,4 ou 8) d'écriture de cette longueur.
		 * Les données contenues dans ces fichiers sont associées à un
		 * descripteur de type.
		 *
		 * Attention : les fichiers non formatés ne sont pas portables
		 * d'une architecture à l'autre.
		 *
		 * Structure d'un enregistrement :
		 * [en-tête][.........données..........][longueur + type de longueur]
		 *
		 * Longueur : (pour l'instruction backspace)
		 *
		 * 00 XXXXXX                longueur sur 6 bits
		 * 01 XXXXXX                longueur sur 16 bits
		 * 10 XXXXXX                longueur sur 32 bits
		 * 11 XXXXXX                longueur sur 64 bits
		 *
		 * Exemples :
		 * [00 XXXXXX]
		 * [01 ----XX][XXXXXXXX][01 XXXXXX]
		 * [10 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][10 XXXXXX]
		 * [11 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX]
		 *         [XXXXXXXX][XXXXXXXX][11 XXXXXX]
		 *
		 * Structures des enregistrements :
		 * chaque type de donnée est associé à une en-tête binaire comprenant
		 * le type de données ainsi que toutes autres informations utiles.
		 *
		 * Représentation binaire :
		 *
		 * 1/ scalaires
		 * 0000 XXXX                Binaire sur XXXX octets
		 *
		 * TYPE
		 * 0001 00 00               integer*1
		 * 0001 00 01               integer*2
		 * 0001 00 10               integer*4
		 * 0001 00 11               integer*8
		 *
		 * 0001 01 00               real*4
		 * 0001 01 01               real*8
		 *
		 * 0001 10 00               complex*8
		 * 0001 10 01               complex*16
		 *
		 * 0010 00 00				vecteur integer*1 (dimensions integer*1)
		 * 0010 01 00				vecteur integer*1 (dimensions integer*2)
		 * 0010 10 00				vecteur integer*1 (dimensions integer*4)
		 * 0010 11 00				vecteur integer*1 (dimensions integer*8)
		 * 0010 00 01				vecteur integer*2 (dimensions integer*1)
		 * 0010 01 01				vecteur integer*2 (dimensions integer*2)
		 * 0010 10 01				vecteur integer*2 (dimensions integer*4)
		 * 0010 11 01				vecteur integer*2 (dimensions integer*8)
		 * 0010 00 10				vecteur integer*4 (dimensions integer*1)
		 * 0010 01 10				vecteur integer*4 (dimensions integer*2)
		 * 0010 10 10				vecteur integer*4 (dimensions integer*4)
		 * 0010 11 10				vecteur integer*4 (dimensions integer*8)
		 * 0010 00 11				vecteur integer*8 (dimensions integer*1)
		 * 0010 01 11				vecteur integer*8 (dimensions integer*2)
		 * 0010 10 11				vecteur integer*8 (dimensions integer*4)
		 * 0010 11 11				vecteur integer*8 (dimensions integer*8)
		 *
		 * 0011 00 00				matrice integer*1 (dimensions integer*1)
		 * 0011 01 00				matrice integer*1 (dimensions integer*2)
		 * 0011 10 00				matrice integer*1 (dimensions integer*4)
		 * 0011 11 00				matrice integer*1 (dimensions integer*8)
		 * 0011 00 01				matrice integer*2 (dimensions integer*1)
		 * 0011 01 01				matrice integer*2 (dimensions integer*2)
		 * 0011 10 01				matrice integer*2 (dimensions integer*4)
		 * 0011 11 01				matrice integer*2 (dimensions integer*8)
		 * 0011 00 10				matrice integer*4 (dimensions integer*1)
		 * 0011 01 10				matrice integer*4 (dimensions integer*2)
		 * 0011 10 10				matrice integer*4 (dimensions integer*4)
		 * 0011 11 10				matrice integer*4 (dimensions integer*8)
		 * 0011 00 11				matrice integer*8 (dimensions integer*1)
		 * 0011 01 11				matrice integer*8 (dimensions integer*2)
		 * 0011 10 11				matrice integer*8 (dimensions integer*4)
		 * 0011 11 11				matrice integer*8 (dimensions integer*8)
		 *
		 * 0100 0 XXX				liste de longueur XXX
		 * 0100 10 00				liste de longueur integer*1
		 * 0100 10 01				liste de longueur integer*2
		 * 0100 10 10				liste de longueur integer*4
		 * 0100 10 11				liste de longueur integer*8
		 *
		 * 0101 0 XXX				nom de longueur XXX
		 * 0101 10 LL				nom de longueur integer*LL
		 *
		 * 0110 0 XXX				expression RPN
		 * 0110 10 LL
		 *
		 * 0111 0 XXX				expression algébrique
		 * 0111 10 LL
		 *
		 * 1000 0 XXX				chaîne de caractères
		 * 1000 10 LL
		 *
		 * 1001 0 XXX				table de longueur XXX
		 * 1001 10 00				table de longueur integer*1
		 * 1001 10 01				table de longueur integer*2
		 * 1001 10 10				table de longueur integer*4
		 * 1001 10 11				table de longueur integer*8
		 *
		 * 1010 00 10				vecteur real*4 (dimensions integer*1)
		 * 1010 01 10				vecteur real*4 (dimensions integer*2)
		 * 1010 10 10				vecteur real*4 (dimensions integer*4)
		 * 1010 11 10				vecteur real*4 (dimensions integer*8)
		 * 1010 00 11				vecteur real*8 (dimensions integer*1)
		 * 1010 01 11				vecteur real*8 (dimensions integer*2)
		 * 1010 10 11				vecteur real*8 (dimensions integer*4)
		 * 1010 11 11				vecteur real*8 (dimensions integer*8)
		 * 1011 00 10				vecteur complex*8 (dimensions integer*1)
		 * 1011 01 10				vecteur complex*8 (dimensions integer*2)
		 * 1011 10 10				vecteur complex*8 (dimensions integer*4)
		 * 1011 11 10				vecteur complex*8 (dimensions integer*8)
		 * 1011 00 11				vecteur complex*16 (dimensions integer*1)
		 * 1011 01 11				vecteur complex*16 (dimensions integer*2)
		 * 1011 10 11				vecteur complex*16 (dimensions integer*4)
		 * 1011 11 11				vecteur complex*16 (dimensions integer*8)
		 *
		 * 1100 00 10				matrice real*4 (dimensions integer*1)
		 * 1100 01 10				matrice real*4 (dimensions integer*2)
		 * 1100 10 10				matrice real*4 (dimensions integer*4)
		 * 1100 11 10				matrice real*4 (dimensions integer*8)
		 * 1100 00 11				matrice real*8 (dimensions integer*1)
		 * 1100 01 11				matrice real*8 (dimensions integer*2)
		 * 1100 10 11				matrice real*8 (dimensions integer*4)
		 * 1100 11 11				matrice real*8 (dimensions integer*8)
		 * 1101 00 10				matrice complex*8 (dimensions integer*1)
		 * 1101 01 10				matrice complex*8 (dimensions integer*2)
		 * 1101 10 10				matrice complex*8 (dimensions integer*4)
		 * 1101 11 10				matrice complex*8 (dimensions integer*8)
		 * 1101 00 11				matrice complex*16 (dimensions integer*1)
		 * 1101 01 11				matrice complex*16 (dimensions integer*2)
		 * 1101 10 11				matrice complex*16 (dimensions integer*4)
		 * 1101 11 11				matrice complex*16 (dimensions integer*8)
		 *
		 * Les longueurs indiquées par le champ LL suivent l'en-tête :
		 * 		00 : integer*1
		 * 		01 : integer*2
		 * 		10 : integer*4
		 * 		11 : integer*8
		 *
		 * [En-tête][longueur_1][longueur_2][données]
		 * le nombre de champs longueur dépendant des types d'enregistrement.
		 *
		 * Toutes les autres combinaisons sont invalides.
		 */

		chaine = NULL;
		chaine_formatee = NULL;
		chaine_sauvegarde = NULL;

		strcpy(base, " ");

		masque_binaire = 0;

		if ((*s_objet).type == ALG)
		{

/*
--------------------------------------------------------------------------------
  Expression algébrique
--------------------------------------------------------------------------------
*/

			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;

			while(l_element_courant != NULL)
			{
				if ((*(*l_element_courant).donnee).type == FCT)
				{
					if ((strcmp((*((struct_fonction *) (*(*l_element_courant)
							.donnee).objet)).nom_fonction, "<<") != 0) &&
							(strcmp((*((struct_fonction *)
							(*(*l_element_courant)
							.donnee).objet)).nom_fonction, ">>") != 0))
					{
						if ((strcmp((*((struct_fonction *)
								(*(*l_element_courant)
								.donnee).objet)).nom_fonction, "+") == 0) ||
								(strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction, "-") == 0) || (strcmp(
								(*((struct_fonction *) (*(*l_element_courant)
								.donnee).objet)).nom_fonction, "*") == 0) ||
								(strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"/") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"^") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"<") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								">") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"==") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"<>") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"<=") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"=<") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								">=") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"=>") == 0))
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_2) == d_erreur)
							{
								return(NULL);
							}

							chaine_sauvegarde = (*s_etat_processus)
									.instruction_courante;

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

							sprintf((*s_etat_processus).instruction_courante,
									"'%s'", (unsigned char *)
									(*s_sous_objet_2).objet);

							presence_signe = (((*s_etat_processus)
									.instruction_courante[1] == '+')
									|| ((*s_etat_processus)
									.instruction_courante[1]
									== '-')) ? d_vrai : d_faux;

							recherche_type(s_etat_processus);

							if ((*s_etat_processus).erreur_execution != d_ex)
							{
								// Aucune erreur ne peut être renvoyée.

								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_3) == d_erreur)
							{
								return(NULL);
							}

							free((*s_etat_processus).instruction_courante);

							(*s_etat_processus).instruction_courante =
									chaine_sauvegarde;

							autorisation_parenthese = d_faux;

							if ((*s_sous_objet_3).type == ALG)
							{
								l_atome = (struct_liste_chainee *)
										(*s_sous_objet_3).objet;
								chaine_fonction = "";
								nombre_arguments_fonction = 0;

								while(l_atome != NULL)
								{
									if ((*(*l_atome).donnee).type == FCT)
									{
										if (strcmp((*((struct_fonction *)
												(*(*l_atome).donnee).objet))
												.nom_fonction, ">>") != 0)
										{
											chaine_fonction =
													(*((struct_fonction *)
													(*(*l_atome).donnee).objet))
													.nom_fonction;
											nombre_arguments_fonction =
													(*((struct_fonction *)
													(*(*l_atome).donnee).objet))
													.nombre_arguments;
										}
									}

									l_atome = (*l_atome).suivant;
								}

								if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "+") == 0)
								{
									if ((strcmp(chaine_fonction, "AND") == 0) ||
											(strcmp(chaine_fonction, "XOR") ==
											0) || (strcmp(chaine_fonction, "OR")
											== 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "-") == 0)
								{
									if (nombre_arguments_fonction != 0)
									{
										autorisation_parenthese = d_faux;
									}
									else
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "*") == 0)
								{
									if ((strcmp(chaine_fonction, "+") == 0) ||
											(strcmp(chaine_fonction, "-") == 0)
											|| (strcmp(chaine_fonction, "AND")
											== 0) || (strcmp(chaine_fonction,
											"XOR") == 0) || (strcmp(
											chaine_fonction, "OR") == 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if (strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "/") == 0)
								{
									if (nombre_arguments_fonction != 0)
									{
										autorisation_parenthese = d_faux;
									}
									else
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "^") == 0))
								{
									if (nombre_arguments_fonction != 0)
									{
										autorisation_parenthese = d_faux;
									}
									else
									{
										autorisation_parenthese = d_vrai;
									}
								}
							}

							if ((autorisation_parenthese == d_vrai) ||
									(presence_signe == d_vrai))
							{
								chaine_sauvegarde = (unsigned char *)
										(*s_sous_objet_2).objet;

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

								sprintf((unsigned char *) (*s_sous_objet_2)
										.objet, "(%s)", chaine_sauvegarde);
								free(chaine_sauvegarde);
							}

							liberation(s_etat_processus, s_sous_objet_3);

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							chaine_sauvegarde = (*s_etat_processus)
									.instruction_courante;

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

							sprintf((*s_etat_processus).instruction_courante,
									"'%s'", (unsigned char *)
									(*s_sous_objet_1).objet);

							recherche_type(s_etat_processus);

							if ((*s_etat_processus).erreur_execution != d_ex)
							{
								// Aucune erreur ne peut être renvoyée.

								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_3) == d_erreur)
							{
								return(NULL);
							}

							free((*s_etat_processus).instruction_courante);

							(*s_etat_processus).instruction_courante =
									chaine_sauvegarde;

							autorisation_parenthese = d_faux;

							if ((*s_sous_objet_3).type == ALG)
							{
								l_atome = (struct_liste_chainee *)
										(*s_sous_objet_3).objet;
								chaine_fonction = "";

								while(l_atome != NULL)
								{
									if ((*(*l_atome).donnee).type == FCT)
									{
										if (strcmp((*((struct_fonction *)
												(*(*l_atome).donnee).objet))
												.nom_fonction, ">>") != 0)
										{
											chaine_fonction =
													(*((struct_fonction *)
													(*(*l_atome).donnee).objet))
													.nom_fonction;
										}
									}

									l_atome = (*l_atome).suivant;
								}

								if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "+") == 0) ||
										(strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "-") == 0))
								{
									if ((strcmp(chaine_fonction, "AND") == 0) ||
											(strcmp(chaine_fonction, "XOR") ==
											0) || (strcmp(chaine_fonction, "OR")
											== 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "*") == 0) ||
										(strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "/") == 0))
								{
									if ((strcmp(chaine_fonction, "+") == 0) ||
											(strcmp(chaine_fonction, "-") == 0)
											|| (strcmp(chaine_fonction, "AND")
											== 0) || (strcmp(chaine_fonction,
											"XOR") == 0) || (strcmp(
											chaine_fonction, "OR") == 0))
									{
										autorisation_parenthese = d_vrai;
									}
								}
								else if ((strcmp((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, "^") == 0))
								{
									autorisation_parenthese = d_vrai;
								}
							}

							if (autorisation_parenthese == d_vrai)
							{
								chaine_sauvegarde = (unsigned char *)
										(*s_sous_objet_1).objet;

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

								sprintf((unsigned char *) (*s_sous_objet_1)
										.objet, "(%s)", chaine_sauvegarde);
								free(chaine_sauvegarde);
							}

							liberation(s_etat_processus, s_sous_objet_3);

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							if (((*s_sous_objet).objet = (void *)
									malloc((strlen(
									(unsigned char *) (*s_sous_objet_1).objet) +
									strlen((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction) + strlen((unsigned char *)
									(*s_sous_objet_2).objet) + 1) *
									sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"%s%s%s", (unsigned char *)
									(*s_sous_objet_1)
									.objet, (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, (unsigned char *)
									(*s_sous_objet_2).objet);

							liberation(s_etat_processus, s_sous_objet_1);
							liberation(s_etat_processus, s_sous_objet_2);

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else if (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction, "=") == 0)
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									&s_sous_objet_2) == d_erreur)
							{
								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									&s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							autorisation_parenthese = d_vrai;
							l_atome = l_element_courant;

							if (l_atome != NULL)
							{
								if ((*l_atome).suivant != NULL)
								{
									l_atome = (*l_atome).suivant;

									if ((*(*l_atome).donnee).type == FCT)
									{
										if (strcmp((*((struct_fonction *)
												(*(*l_atome).donnee).objet))
												.nom_fonction, ">>") == 0)
										{
											if ((*l_atome).suivant == NULL)
											{
												autorisation_parenthese =
														d_faux;
											}
										}
									}
								}
							}

							if (autorisation_parenthese == d_vrai)
							{
								if (((*s_sous_objet).objet =
										(void *) malloc((strlen(
										(unsigned char *) (*s_sous_objet_1)
										.objet) + strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) +
										strlen((unsigned char *)
										(*s_sous_objet_2).objet) + 2 + 1) *
										sizeof(unsigned char))) == NULL)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_allocation_memoire;
									return(NULL);
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"(%s%s%s)", (unsigned char *)
										(*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}
							else
							{
								if (((*s_sous_objet).objet =
										(void *) malloc((strlen(
										(unsigned char *) (*s_sous_objet_1)
										.objet) + strlen((*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction) + strlen(
										(unsigned char *) (*s_sous_objet_2)
										.objet) + 1) * sizeof(unsigned char)))
										== NULL)
								{
									(*s_etat_processus).erreur_systeme =
											d_es_allocation_memoire;
									return(NULL);
								}

								sprintf((unsigned char *) (*s_sous_objet).objet,
										"%s%s%s", (unsigned char *)
										(*s_sous_objet_1)
										.objet, (*((struct_fonction *)
										(*(*l_element_courant).donnee).objet))
										.nom_fonction, (unsigned char *)
										(*s_sous_objet_2).objet);
							}

							liberation(s_etat_processus, s_sous_objet_1);
							liberation(s_etat_processus, s_sous_objet_2);

							if (empilement(s_etat_processus,
									&((*s_etat_processus).l_base_pile),
									s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else if (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"NOT") == 0)
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							if (((*s_sous_objet).objet = (unsigned char *)
									malloc(
									(strlen((unsigned char *) (*s_sous_objet_1)
									.objet) + 4 + 1) * sizeof(unsigned char)))
									== NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"%s %s", (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, (unsigned char *)
									(*s_sous_objet_1).objet );

							liberation(s_etat_processus, s_sous_objet_1);

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else if ((strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"OR") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"XOR") == 0) || (strcmp((*((struct_fonction *)
								(*(*l_element_courant).donnee).objet))
								.nom_fonction,
								"AND") == 0))
						{
							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_2) == d_erreur)
							{
								return(NULL);
							}

							if (depilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), &s_sous_objet_1) == d_erreur)
							{
								return(NULL);
							}

							if ((s_sous_objet = allocation(s_etat_processus,
									CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							if (((*s_sous_objet).objet = (void *)
									malloc((strlen(
									(unsigned char *) (*s_sous_objet_1).objet) +
									strlen((*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction) + strlen((unsigned char *)
									(*s_sous_objet_2).objet) + 2 + 1) *
									sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf((unsigned char *) (*s_sous_objet).objet,
									"%s %s %s", (unsigned char *)
									(*s_sous_objet_1)
									.objet, (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, (unsigned char *)
									(*s_sous_objet_2).objet);

							liberation(s_etat_processus, s_sous_objet_1);
							liberation(s_etat_processus, s_sous_objet_2);

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
						else
						{
							nombre_arguments = (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nombre_arguments;

							if ((chaine = (unsigned char *)
									malloc(sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}
							
							chaine[0] = d_code_fin_chaine;

							for(i = 0; i < nombre_arguments; i++)
							{
								if ((nombre_arguments - i) > 1)
								{
									l_liste1 = (*s_etat_processus).l_base_pile;

									for(j = 2; j < (nombre_arguments - i); j++)
									{
										l_liste1 = (*l_liste1).suivant;
									}

									l_liste2 = (*l_liste1).suivant;
									(*l_liste1).suivant = (*l_liste2).suivant;
									(*l_liste2).suivant = (*s_etat_processus)
											.l_base_pile;
									(*s_etat_processus).l_base_pile = l_liste2;
								}
								
								if (depilement(s_etat_processus,
										&((*s_etat_processus).l_base_pile),
										&s_sous_objet) == d_erreur)
								{
									return(NULL);
								}

								chaine_sauvegarde = chaine;

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

									sprintf(chaine, "%s", (unsigned char *)
											(*s_sous_objet).objet);
								}
								else
								{
									if ((chaine = (unsigned char *)
											malloc((strlen(chaine_sauvegarde)
											+ 1 + strlen((unsigned char *)
											(*s_sous_objet).objet) + 1) *
											sizeof(unsigned char))) == NULL)
									{
										(*s_etat_processus).erreur_systeme =
												d_es_allocation_memoire;
										return(NULL);
									}

									sprintf(chaine, "%s,%s", chaine_sauvegarde,
											(unsigned char *) (*s_sous_objet)
											.objet);
								}

								free(chaine_sauvegarde);
								liberation(s_etat_processus, s_sous_objet);
							}

							chaine_sauvegarde = chaine;

							if ((chaine = (unsigned char *) malloc((strlen(
									(*((struct_fonction *)
									(*(*l_element_courant)
									.donnee).objet)).nom_fonction) + 2 +
									strlen(chaine_sauvegarde) + 1) *
									sizeof(unsigned char))) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

							sprintf(chaine, "%s(%s)", (*((struct_fonction *)
									(*(*l_element_courant).donnee).objet))
									.nom_fonction, chaine_sauvegarde);
							free(chaine_sauvegarde);

							if ((s_sous_objet = allocation(s_etat_processus,
											CHN)) == NULL)
							{
								(*s_etat_processus).erreur_systeme =
										d_es_allocation_memoire;
								return(NULL);
							}

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

							if (empilement(s_etat_processus,
									&((*s_etat_processus)
									.l_base_pile), s_sous_objet) == d_erreur)
							{
								return(NULL);
							}
						}
					}
				}
				else
				{
					if ((s_sous_objet = allocation(s_etat_processus, CHN))
							== NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					if (((*s_sous_objet).objet = (void *) formateur_fichier(
							s_etat_processus, (*l_element_courant).donnee,
							s_format, longueur, longueur_champ, format_sortie,
							type, longueur_effective, recursivite)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					if (((*(*l_element_courant).donnee).type == ALG)
							|| ((*(*l_element_courant).donnee).type == NOM))
					{
						chaine_sauvegarde = (unsigned char *)
								(*s_sous_objet).objet;

						if (((*s_sous_objet).objet = malloc((strlen(
								chaine_sauvegarde) - 1) *
								sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						ptrl = chaine_sauvegarde;
						ptre = (unsigned char *) (*s_sous_objet).objet;

						for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;
								i--, *ptre++ = *ptrl++);

						(*ptre) = d_code_fin_chaine;

						free(chaine_sauvegarde);
					}
					else if ((*(*l_element_courant).donnee).type == CHN)
					{
						chaine_sauvegarde = (unsigned char *)
								(*s_sous_objet).objet;

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

						sprintf((unsigned char *) (*s_sous_objet).objet,
								"\"%s\"", chaine_sauvegarde);

						free(chaine_sauvegarde);
					}

					if (empilement(s_etat_processus, &((*s_etat_processus)
							.l_base_pile), s_sous_objet) == d_erreur)
					{
						return(NULL);
					}
				}

				l_element_courant = (*l_element_courant).suivant;
			}

			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
					&s_sous_objet) == d_erreur)
			{
				return(NULL);
			}

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

			sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet);
			liberation(s_etat_processus, s_sous_objet);
		}
		else if ((*s_objet).type == BIN)
		{

/*
--------------------------------------------------------------------------------
  Entier binaire en base 2, 8, 10 ou 16
--------------------------------------------------------------------------------
*/

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

			masque_binaire = masque_entiers_binaires(s_etat_processus);

			if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
					(test_cfsf(s_etat_processus, 44) == d_faux))
			{

/*
-- Base décimale ---------------------------------------------------------------
*/

				sprintf(tampon, "%llu", (*((logical8 *)
						((*s_objet).objet))) & masque_binaire);
				strcpy(base, "d");
			}
			else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
					(test_cfsf(s_etat_processus, 44) == d_faux))
			{

/*
-- Base octale -----------------------------------------------------------------
*/

				sprintf(tampon, "%llo", (*((logical8 *)
						((*s_objet).objet))) & masque_binaire);
				strcpy(base, "o");
			}
			else if (test_cfsf(s_etat_processus, 44) == d_vrai)
			{

/*
-- Bases hexadécimale et binaire -----------------------------------------------
*/

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

				if (test_cfsf(s_etat_processus, 43) == d_vrai)
				{
					strcpy(base, "h");
				}
				else
				{
					chaine = (unsigned char *) malloc((strlen(tampon) + 1)
							* sizeof(unsigned char));

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

					strcpy(chaine, tampon);
					tampon[0] = 0;

					for(i = 0; i < strlen(chaine); i++)
					{
						switch(chaine[i])
						{
							case '0' :
							{
								strcat(tampon, (i != 0) ? "0000" : "0");
								break;
							}
							case '1' :
							{
									strcat(tampon, (i != 0) ? "0001" : "1");
								break;
							}
							case '2' :
							{
								strcat(tampon, (i != 0) ? "0010" : "10");
								break;
							}
							case '3' :
							{
								strcat(tampon, (i != 0) ? "0011" : "11");
								break;
							}
							case '4' :
							{
								strcat(tampon, (i != 0) ? "0100" : "100");
								break;
							}
							case '5' :
							{
								strcat(tampon, (i != 0) ? "0101" : "101");
								break;
							}
							case '6' :
							{
								strcat(tampon, (i != 0) ? "0110" : "110");
								break;
							}
							case '7' :
							{
								strcat(tampon, (i != 0) ? "0111" : "111");
								break;
							}
							case '8' :
							{
								strcat(tampon, "1000");
								break;
							}
							case '9' :
							{
								strcat(tampon, "1001");
								break;
							}
							case 'A' :
							{
								strcat(tampon, "1010");
								break;
							}
							case 'B' :
							{
								strcat(tampon, "1011");
								break;
							}
							case 'C' :
							{
								strcat(tampon, "1100");
								break;
							}
							case 'D' :
							{
								strcat(tampon, "1101");
								break;
							}
							case 'E' :
							{
								strcat(tampon, "1110");
								break;
							}
							case 'F' :
							{
								strcat(tampon, "1111");
								break;
							}
						}
					}

					free(chaine);
					strcpy(base, "b");
				}
			}

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

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

			strcpy(chaine, "# ");

			strcat(chaine, tampon);
			strcat(chaine, base);
		}
		else if ((*s_objet).type == CHN)
		{

/*
--------------------------------------------------------------------------------
  Chaîne de caractères
--------------------------------------------------------------------------------
*/

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

			chaine = (unsigned char *) malloc((strlen((unsigned char *)
					((*s_objet).objet)) + 1) * sizeof(unsigned char));

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

			strcpy(chaine, (unsigned char *) ((*s_objet).objet));
		}
		else if ((*s_objet).type == CPL)
		{

/*
--------------------------------------------------------------------------------
  Complexe
--------------------------------------------------------------------------------
*/

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

			if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
					(*s_objet).objet, 'C', longueur, longueur_effective))
					== NULL)
			{
				return(NULL);
			}
		}
		else if ((*s_objet).type == RPN)
		{

/*
--------------------------------------------------------------------------------
  Définition
--------------------------------------------------------------------------------
*/

			l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
			chaine_sauvegarde = chaine;

			while(l_element_courant != NULL)
			{
				if ((chaine_formatee = formateur_fichier(s_etat_processus,
						(*l_element_courant).donnee, s_format,
						longueur, longueur_champ, format_sortie, type,
						longueur_effective, recursivite)) == NULL)
				{
					return(NULL);
				}

				if ((*(*l_element_courant).donnee).type == CHN)
				{
					chaine_tampon = chaine_formatee;

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

					sprintf(chaine_formatee, "\"%s\"", chaine_tampon);
					free(chaine_tampon);
				}

				l_element_courant = (*l_element_courant).suivant;

				if (chaine != NULL)
				{
					chaine_sauvegarde = chaine;

					if ((chaine = (unsigned char *) malloc((strlen(
							chaine_sauvegarde) + strlen(chaine_formatee) + 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}
				else
				{
					chaine = chaine_formatee;
				}
			}

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

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

			chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine;
			strcpy(chaine, chaine_sauvegarde);
			free(chaine_sauvegarde);
		}
		else if ((*s_objet).type == INT)
		{

/*
--------------------------------------------------------------------------------
  Entier
--------------------------------------------------------------------------------
*/

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

			if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
					(*s_objet).objet, 'I', longueur, longueur_effective))
					== NULL)
			{
				return(NULL);
			}
		}
		else if ((*s_objet).type == FCT)
		{

/*
--------------------------------------------------------------------------------
  Fonction
--------------------------------------------------------------------------------
*/

			chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
					((*s_objet).objet))).nom_fonction) + 1) *
					sizeof(unsigned char));

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

			strcpy(chaine, (unsigned char *) (*((struct_fonction *)
					((*s_objet).objet))).nom_fonction);
		}
		else if ((*s_objet).type == LST)
		{

/*
--------------------------------------------------------------------------------
  Liste
  Poids fort 0100
--------------------------------------------------------------------------------
*/

			chaine = malloc(sizeof(unsigned char));

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

			// Calcul de la longueur de la liste.

			longueur_liste = 0;
			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;

			while(l_element_courant != NULL)
			{
				l_element_courant = (*l_element_courant).suivant;
				longueur_liste++;
			}

			if (longueur_liste < (1LL << 3))
			{
				chaine[0] = 0x40 | (longueur_liste & 0x7);
			}
			else if (longueur_liste < (1LL << 8))
			{
				chaine[0] = 0x48;
			}
			else if (longueur_liste < (1LL << 16))
			{
				chaine[0] = 0x49;
			}
			else if (longueur_liste < (1LL << 32))
			{
				chaine[0] = 0x4A;
			}
			else
			{
				chaine[0] = 0x4B;
			}

			longueur_totale = 1;

			if ((chaine[0] & 0x8) != 0)
			{
				switch(chaine[0] & 0x03)
				{
					case 0x00 :
					{
						longueur_totale += 1;

						if ((chaine = realloc(chaine, longueur_totale *
								sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine[longueur_totale - 1] =
								(unsigned char) (longueur_liste & 0xFF);
						break;
					}

					case 0x01 :
					{
						longueur_totale += 2;

						if ((chaine = realloc(chaine, longueur_totale *
								sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine[longueur_totale - 2] =
								(unsigned char) ((longueur_liste >> 8) & 0xFF);
						chaine[longueur_totale - 1] =
								(unsigned char) (longueur_liste & 0xFF);
						break;
					}

					case 0x02 :
					{
						longueur_totale += 4;

						if ((chaine = realloc(chaine, longueur_totale *
								sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine[longueur_totale - 4] =
								(unsigned char) ((longueur_liste >> 24) & 0xFF);
						chaine[longueur_totale - 3] =
								(unsigned char) ((longueur_liste >> 16) & 0xFF);
						chaine[longueur_totale - 2] =
								(unsigned char) ((longueur_liste >> 8) & 0xFF);
						chaine[longueur_totale - 1] =
								(unsigned char) (longueur_liste & 0xFF);
						break;
					}

					case 0x03 :
					{
						longueur_totale += 8;

						if ((chaine = realloc(chaine, longueur_totale *
								sizeof(unsigned char))) == NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine[longueur_totale - 8] =
								(unsigned char) ((longueur_liste >> 56) & 0xFF);
						chaine[longueur_totale - 7] =
								(unsigned char) ((longueur_liste >> 48) & 0xFF);
						chaine[longueur_totale - 6] =
								(unsigned char) ((longueur_liste >> 40) & 0xFF);
						chaine[longueur_totale - 5] =
								(unsigned char) ((longueur_liste >> 32) & 0xFF);
						chaine[longueur_totale - 4] =
								(unsigned char) ((longueur_liste >> 24) & 0xFF);
						chaine[longueur_totale - 3] =
								(unsigned char) ((longueur_liste >> 16) & 0xFF);
						chaine[longueur_totale - 2] =
								(unsigned char) ((longueur_liste >> 8) & 0xFF);
						chaine[longueur_totale - 1] =
								(unsigned char) (longueur_liste & 0xFF);
						break;
					}

					default :
					{
						BUG(1, printf("Internal format error\n"));
					}
				}
			}

			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
			l_element_courant_format = (struct_liste_chainee *)
					(*s_format).objet;
			nombre_elements = 0;

			while((l_element_courant != NULL) &&
					(l_element_courant_format != NULL))
			{
				if ((((*(*l_element_courant_format).donnee).type == LST)
						&& ((*(*l_element_courant).donnee).type == LST)) ||
						(((*(*l_element_courant_format).donnee).type == TBL)
						&& ((*(*l_element_courant).donnee).type == TBL)))
				{
					if ((chaine_formatee = formateur_fichier(s_etat_processus,
							(*l_element_courant).donnee,
							(*l_element_courant_format).donnee,
							0, 0, ' ', 'U', longueur_effective, recursivite))
							== NULL)
					{
						return(NULL);
					}

					if ((chaine = realloc(chaine, (longueur_totale +
							(*longueur_effective)) * sizeof(unsigned char)))
							== NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					memcpy(&(chaine[longueur_totale]), chaine_formatee,
							(*longueur_effective));
					longueur_totale += (*longueur_effective);
					free(chaine_formatee);
				}
				else if ((*(*l_element_courant_format).donnee).type != CHN)
				{
					free(chaine);

					(*s_etat_processus).erreur_execution =
							d_ex_erreur_format_fichier;
					return(NULL);
				}
				else
				{
					if ((format_chaine = conversion_majuscule((unsigned char *)
							(*(*l_element_courant_format).donnee).objet))
							== NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					format_degenere = d_faux;

					if (strncmp("INTEGER*", format_chaine, 8) == 0)
					{
						format_sortie = 'I';
						position_1 = 8;
					}
					else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
					{
						format_sortie = 'L';
						position_1 = 8;
					}
					else if (strncmp("REAL*", format_chaine, 5) == 0)
					{
						format_sortie = 'R';
						position_1 = 5;
					}
					else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
					{
						format_sortie = 'C';
						position_1 = 8;
					}
					else if (strcmp("CHARACTER", format_chaine) == 0)
					{
						format_sortie = 'S';
						position_1 = 10;
						format_degenere = d_vrai;
					}
					else
					{
						free(chaine);
						free(format_chaine);

						(*s_etat_processus).erreur_execution =
								d_ex_erreur_format_fichier;
						return(NULL);
					}

					if (format_degenere == d_faux)
					{
						if (format_chaine[position_1] == d_code_fin_chaine)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}

						if (sscanf(&(format_chaine[position_1]), "%ld",
								&longueur) != 1)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}
					}
					else
					{
						longueur = -1;
					}

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

					if ((chaine = realloc(chaine,
							(longueur_totale + (*longueur_effective))
							* sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					memcpy(&(chaine[longueur_totale]), chaine_formatee,
							(*longueur_effective));
					longueur_totale += (*longueur_effective);
					free(chaine_formatee);
				}

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

			if ((l_element_courant != NULL) ||
					(l_element_courant_format != NULL))
			{
				free(chaine);

				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			if ((*recursivite) == 1)
			{
				// Ajout de la longueur totale en fin d'enregistrement.

				if (longueur_totale < (((integer8) 1) << 6))
				{
					tampon[0] = longueur_totale + 1;

					if ((chaine = realloc(chaine, (longueur_totale + 1)
							* sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					memcpy(&(chaine[longueur_totale]), tampon, 1);
					longueur_totale += 1;
				}
				else if (longueur_totale < (((integer8) 1) << 16))
				{
					tampon[2] = 0x40;
					tampon[1] = (longueur_totale + 1) & 0xFF;
					tampon[0] = ((longueur_totale + 1) >> 8) & 0xFF;

					if ((chaine = realloc(chaine, (longueur_totale + 3)
							* sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					memcpy(&(chaine[longueur_totale]), tampon, 3);
					longueur_totale += 3;
				}
				else if (longueur_totale < (((integer8) 1) << 32))
				{
					tampon[4] = 0x80;
					tampon[3] = (longueur_totale + 1) & 0xFF;
					tampon[2] = ((longueur_totale + 1) >> 8) & 0xFF;
					tampon[1] = ((longueur_totale + 1) >> 16) & 0xFF;
					tampon[0] = ((longueur_totale + 1) >> 24) & 0xFF;

					if ((chaine = realloc(chaine, (longueur_totale + 5)
							* sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					memcpy(&(chaine[longueur_totale]), tampon, 5);
					longueur_totale += 5;
				}
				else
				{
					tampon[8] = 0xC0;
					tampon[7] = (longueur_totale + 1) & 0xFF;
					tampon[6] = ((longueur_totale + 1) >> 8) & 0xFF;
					tampon[5] = ((longueur_totale + 1) >> 16) & 0xFF;
					tampon[4] = ((longueur_totale + 1) >> 24) & 0xFF;
					tampon[3] = ((longueur_totale + 1) >> 32) & 0xFF;
					tampon[2] = ((longueur_totale + 1) >> 40) & 0xFF;
					tampon[1] = ((longueur_totale + 1) >> 48) & 0xFF;
					tampon[0] = ((longueur_totale + 1) >> 56) & 0xFF;

					if ((chaine = realloc(chaine, (longueur_totale + 9)
							* sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					memcpy(&(chaine[longueur_totale]), tampon, 9);
					longueur_totale += 9;
				}

				__zone();
			}

			(*longueur_effective) = longueur_totale;
		}
		else if ((*s_objet).type == TBL)
		{

/*
--------------------------------------------------------------------------------
  Table
--------------------------------------------------------------------------------
*/

			if ((*s_format).type != TBL)
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
			l_element_courant_format = (struct_liste_chainee *)
					(*s_format).objet;

			if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
					(*((struct_tableau *) (*s_format).objet)).nombre_elements)
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

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

			strcpy(chaine, "<[");

			for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
					.nombre_elements; i++)
			{
				if ((((*(*((struct_tableau *) (*s_format).objet))
						.elements[i]).type == LST) &&
						((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
						.type == LST)) ||
						(((*(*((struct_tableau *) (*s_format).objet))
						.elements[i]).type == TBL) &&
						((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
						.type == TBL)))
				{
					chaine_sauvegarde = chaine;

					if ((chaine_formatee = formateur_fichier(s_etat_processus,
							(*l_element_courant).donnee,
							(*l_element_courant_format).donnee,
							0, 0, ' ', 'F', longueur_effective, recursivite))
							== NULL)
					{
						return(NULL);
					}

					chaine = (unsigned char *) malloc((strlen(chaine_formatee)
							+ strlen(chaine_sauvegarde) + 2)
							* 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}
				else if ((*(*((struct_tableau *) (*s_format).objet))
						.elements[i]).type != CHN)
				{
					free(chaine);

					(*s_etat_processus).erreur_execution =
							d_ex_erreur_format_fichier;
					return(NULL);
				}
				else
				{
					if ((format_chaine = conversion_majuscule((unsigned char *)
							(*(*((struct_tableau *) (*s_format).objet))
							.elements[i]).objet)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					format_degenere = d_faux;

					if (strncmp("STANDARD*", format_chaine, 9) == 0)
					{
						format_sortie = 'S';
						position_1 = 9;
						format_degenere = d_vrai;
					}
					else if (strncmp("BINARY*", format_chaine, 7) == 0)
					{
						format_sortie = 'B';
						position_1 = 7;
					}
					else if (strncmp("FIXED*", format_chaine, 6) == 0)
					{
						format_sortie = 'F';
						position_1 = 6;
					}
					else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
					{
						format_sortie = 'I';
						position_1 = 11;
					}
					else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
					{
						format_sortie = 'E';
						position_1 = 9;
					}
					else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
					{
						format_sortie = 'C';
						position_1 = 10;
						format_degenere = d_vrai;
					}
					else
					{
						free(chaine);
						free(format_chaine);

						(*s_etat_processus).erreur_execution =
								d_ex_erreur_format_fichier;
						return(NULL);
					}

					position_3 = strlen(format_chaine);
					format_chaine[--position_3] = d_code_fin_chaine;

					position_2 = position_1;

					while(format_chaine[position_2] != '(')
					{
						if (format_chaine[position_2] == d_code_fin_chaine)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}

						position_2++;
					}

					format_chaine[position_2++] = d_code_fin_chaine;

					if (format_degenere == d_faux)
					{
						if (sscanf(&(format_chaine[position_1]), "%ld",
								&longueur) != 1)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}
					}
					else
					{
						longueur = -1;
					}

					if (strcmp(&(format_chaine[position_2]), "*") != 0)
					{
						if (sscanf(&(format_chaine[position_2]), "%ld",
								&longueur_champ) != 1)
						{
							free(chaine);
							free(format_chaine);

							(*s_etat_processus).erreur_execution =
									d_ex_erreur_format_fichier;
							return(NULL);
						}
					}
					else
					{
						longueur_champ = -1;
					}

					if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
							longueur_champ))
					{
						free(chaine);
						free(format_chaine);

						(*s_etat_processus).erreur_execution =
								d_ex_erreur_format_fichier;
						return(NULL);
					}

					free(format_chaine);
				
					chaine_sauvegarde = chaine;

					if ((chaine_formatee = formateur_fichier(s_etat_processus,
							(*((struct_tableau *) (*s_objet).objet))
							.elements[i], s_format,
							longueur, longueur_champ, format_sortie, type,
							longueur_effective, recursivite)) == NULL)
					{
						return(NULL);
					}

					if ((*(*((struct_tableau *) (*s_objet).objet))
							.elements[i]).type == CHN)
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ 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, " \"");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
						strcat(chaine, "\"");
					}
					else if ((*(*((struct_tableau *) (*s_objet).objet))
							.elements[i]).type == NOM)
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ strlen(chaine_sauvegarde) + 2)
								* sizeof(unsigned char));

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

						sprintf(chaine, "%s %s", chaine_sauvegarde,
								chaine_formatee);
						free(chaine_formatee);
					}
					else
					{
						chaine = (unsigned char *)
								malloc((strlen(chaine_formatee)
								+ strlen(chaine_sauvegarde) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						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 == MCX)
		{

/*
--------------------------------------------------------------------------------
  Matrice complexe
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_lignes;
			nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_colonnes;

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[[");

				for(i = 0; i < nombre_lignes; i++)
				{
					for(j = 0; j < nombre_colonnes; j++)
					{
						if ((chaine_formatee =
								formateur_fichier_nombre(s_etat_processus,
								(void *) &(((struct_complexe16 **)
								((*((struct_matrice *)
								((*s_objet).objet))).tableau))[i][j]), 'C',
								longueur, longueur_champ, format_sortie))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine_sauvegarde = chaine;
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) +
								strlen(chaine_formatee) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
					}

					chaine_sauvegarde = chaine;
					if (test_cfsf(s_etat_processus, 45) == d_vrai)
					{
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) + 6)
								* 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, " ]\n [");
					}
					else
					{
						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, " ][");
					}
				}

				if (test_cfsf(s_etat_processus, 45) == d_vrai)
				{
					chaine[strlen(chaine) - 3] = ']';
					chaine[strlen(chaine) - 2] = 0;

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

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

					strcpy(chaine, chaine_sauvegarde);
					free(chaine_sauvegarde);
				}
				else
				{
					chaine[strlen(chaine) - 2] = ']';
					chaine[strlen(chaine) - 1] = 0;

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
							+ 2) * 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 == MIN)
		{

/*
--------------------------------------------------------------------------------
  Matrice entière
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_lignes;
			nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_colonnes;

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[[");

				for(i = 0; i < nombre_lignes; i++)
				{
					for(j = 0; j < nombre_colonnes; j++)
					{
						if ((chaine_formatee =
								formateur_fichier_nombre(s_etat_processus,
								(void *) &(((integer8 **) ((*((struct_matrice *)
								((*s_objet).objet))).tableau))[i][j]), 'I',
								longueur, longueur_champ, format_sortie))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine_sauvegarde = chaine;
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) +
								strlen(chaine_formatee) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
					}

					chaine_sauvegarde = chaine;
					if (test_cfsf(s_etat_processus, 45) == d_vrai)
					{
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) + 6)
								* 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, " ]\n [");
					}
					else
					{
						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, " ][");
					}
				}

				if (test_cfsf(s_etat_processus, 45) == d_vrai)
				{
					chaine[strlen(chaine) - 3] = ']';
					chaine[strlen(chaine) - 2] = 0;

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

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

					strcpy(chaine, chaine_sauvegarde);
					free(chaine_sauvegarde);
				}
				else
				{
					chaine[strlen(chaine) - 2] = ']';
					chaine[strlen(chaine) - 1] = 0;

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
							+ 2) * 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 == MRL)
		{

/*
--------------------------------------------------------------------------------
  Matrice réelle
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

			nombre_lignes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_lignes;
			nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet)))
					.nombre_colonnes;

			chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[[");

				for(i = 0; i < nombre_lignes; i++)
				{
					for(j = 0; j < nombre_colonnes; j++)
					{
						if ((chaine_formatee =
								formateur_fichier_nombre(s_etat_processus,
								(void *) &(((real8 **) ((*((struct_matrice *)
								((*s_objet).objet))).tableau))[i][j]), 'R',
								longueur, longueur_champ, format_sortie))
								== NULL)
						{
							(*s_etat_processus).erreur_systeme =
									d_es_allocation_memoire;
							return(NULL);
						}

						chaine_sauvegarde = chaine;
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) +
								strlen(chaine_formatee) + 2)
								* 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, " ");
						strcat(chaine, chaine_formatee);
						free(chaine_formatee);
					}

					chaine_sauvegarde = chaine;
					if (test_cfsf(s_etat_processus, 45) == d_vrai)
					{
						chaine = (unsigned char *) malloc(
								(strlen(chaine_sauvegarde) + 6)
								* 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, " ]\n [");
					}
					else
					{
						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, " ][");
					}
				}

				if (test_cfsf(s_etat_processus, 45) == d_vrai)
				{
					chaine[strlen(chaine) - 3] = ']';
					chaine[strlen(chaine) - 2] = 0;

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

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

					strcpy(chaine, chaine_sauvegarde);
					free(chaine_sauvegarde);
				}
				else
				{
					chaine[strlen(chaine) - 2] = ']';
					chaine[strlen(chaine) - 1] = 0;

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde)
							+ 2) * 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 == NOM)
		{

/*
--------------------------------------------------------------------------------
  Nom
--------------------------------------------------------------------------------
*/

			chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
					(*s_objet).objet)).nom) + 3) * sizeof(unsigned char));

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

			sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom);
		}
		else if ((*s_objet).type == REL)
		{

/*
--------------------------------------------------------------------------------
  Réel
--------------------------------------------------------------------------------
*/

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

			if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
					(*s_objet).objet, 'R', longueur, longueur_effective))
					== NULL)
			{
				return(NULL);
			}
		}
		else if ((*s_objet).type == VCX)
		{

/*
--------------------------------------------------------------------------------
  Vecteur complexe
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

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

			chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[");

				for(i = 0; i < nombre_colonnes; i++)
				{
					if ((chaine_formatee =
							formateur_fichier_nombre(s_etat_processus,
							(void *) &(((struct_complexe16 *)
							((*((struct_vecteur *)
							((*s_objet).objet))).tableau))[i]), 'C',
							longueur, longueur_champ, format_sortie)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc(
							(strlen(chaine_sauvegarde) + strlen(chaine_formatee)
							+ 2) * 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}

				chaine_sauvegarde = chaine;
				chaine = (unsigned char *) malloc(
						(strlen(chaine_sauvegarde) + 3)
						* 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 == VIN)
		{

/*
--------------------------------------------------------------------------------
  Vecteur entier
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

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

			chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[");

				for(i = 0; i < nombre_colonnes; i++)
				{
					if ((chaine_formatee =
							formateur_fichier_nombre(s_etat_processus,
							(void *) &(((integer8 *) ((*((struct_vecteur *)
							((*s_objet).objet))).tableau))[i]), 'I',
							longueur, longueur_champ, format_sortie)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc(
							(strlen(chaine_sauvegarde) + strlen(chaine_formatee)
							+ 2) * 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}

				chaine_sauvegarde = chaine;
				chaine = (unsigned char *) malloc(
						(strlen(chaine_sauvegarde) + 3)
						* 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 == VRL)
		{

/*
--------------------------------------------------------------------------------
  Vecteur réel
--------------------------------------------------------------------------------
*/

			if ((format_sortie != 'S') && (format_sortie != 'F') &&
					(format_sortie != 'I') && (format_sortie != 'E'))
			{
				(*s_etat_processus).erreur_execution =
						d_ex_erreur_format_fichier;
				return(NULL);
			}

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

			chaine = (unsigned char *) malloc(2 * sizeof(unsigned char));

			if (chaine != NULL)
			{
				strcpy(chaine, "[");

				for(i = 0; i < nombre_colonnes; i++)
				{
					if ((chaine_formatee =
							formateur_fichier_nombre(s_etat_processus,
							(void *) &(((real8 *) ((*((struct_vecteur *)
							((*s_objet).objet))).tableau))[i]), 'R',
							longueur, longueur_champ, format_sortie)) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					chaine_sauvegarde = chaine;
					chaine = (unsigned char *) malloc(
							(strlen(chaine_sauvegarde) + strlen(chaine_formatee)
							+ 2) * 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, " ");
					strcat(chaine, chaine_formatee);
					free(chaine_formatee);
				}

				chaine_sauvegarde = chaine;
				chaine = (unsigned char *) malloc(
						(strlen(chaine_sauvegarde) + 3)
						* 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
		{
			// Type non exportable

			(*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier;
			free(chaine);

			return(NULL);
		}
	}

	(*recursivite)--;

	return(chaine);
}


/*
================================================================================
  Routines qui transforment un nombre entier, réel ou complexe en chaîne de
  caractères suivant le format courant
================================================================================
  Entrées : pointeur générique sur la donnée numérique à convertir,
  type de l'entité (I, R ou C).
--------------------------------------------------------------------------------
  Sorties : chaîne de caractères allouée dans la routine
--------------------------------------------------------------------------------
  Effets de bord : néant
================================================================================
*/

/*
--------------------------------------------------------------------------------
  Formatage des complexes, réels et entiers
--------------------------------------------------------------------------------
*/

unsigned char *
formateur_fichier_nombre(struct_processus *s_etat_processus,
		void *valeur_numerique, unsigned char type,
		long longueur, long longueur_champ, unsigned char format)
{
	unsigned char				*chaine;
	unsigned char				*construction_chaine;
	unsigned char				*sauvegarde;
	unsigned char				*tampon;

	chaine = NULL;

	switch(type)
	{
		case 'C' :
		{
			construction_chaine = (unsigned char *) malloc(
					2 * sizeof(unsigned char));

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

			strcpy(construction_chaine, "(");

			tampon = formateur_fichier_reel(s_etat_processus,
					(void *) &((*((struct_complexe16 *)
					valeur_numerique)).partie_reelle), 'R',
					longueur, longueur_champ, format);

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

			sauvegarde = construction_chaine;

			construction_chaine = (unsigned char *) malloc(
					(strlen(sauvegarde) + strlen(tampon) + 2)
					* sizeof(unsigned char));

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

			strcpy(construction_chaine, sauvegarde);
			free(sauvegarde);
			strcat(construction_chaine, tampon);
			free(tampon);

			strcat(construction_chaine, ",");

			tampon = formateur_fichier_reel(s_etat_processus,
					(void *) &((*((struct_complexe16 *)
					valeur_numerique)).partie_imaginaire), 'R',
					longueur, longueur_champ, format);

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

			sauvegarde = construction_chaine;

			construction_chaine = (unsigned char *) malloc(
					(strlen(sauvegarde) + strlen(tampon) + 2)
					* sizeof(unsigned char));

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

			strcpy(construction_chaine, sauvegarde);
			free(sauvegarde);
			strcat(construction_chaine, tampon);
			free(tampon);
			strcat(construction_chaine, ")");

			chaine = construction_chaine;

			break;
		}

		case 'R' :
		{
			chaine = formateur_fichier_reel(s_etat_processus,
					valeur_numerique, 'R', longueur, longueur_champ,
					format);

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

			break;
		}

		default :
		case 'I' :
		{
			chaine = formateur_fichier_reel(s_etat_processus,
					valeur_numerique, 'I', longueur, longueur_champ,
					format);

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

			break;
		}
	}

	return(chaine);
}


/*
--------------------------------------------------------------------------------
  Formateur des réels et entiers
--------------------------------------------------------------------------------
*/

unsigned char *
formateur_fichier_reel(struct_processus *s_etat_processus,
		void *valeur_numerique, unsigned char type,
		long longueur, long longueur_champ,
		unsigned char format_sortie)
{
	real8					mantisse;
	real8					tampon_reel;

	integer8				tampon_entier;

	long					correction;
	long					exposant;
	long					longueur_utile;
	long					longueur_utile_limite;

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

	unsigned long			i;

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

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

	if (type == 'R')
	{
		tampon_reel = *((real8 *) valeur_numerique);

		if (tampon_reel > ((real8) 0))
		{
			exposant = (long) floor(log10(tampon_reel));
		}
		else if (tampon_reel < ((real8) 0))
		{
			exposant = (long) floor(log10(-tampon_reel));
		}
		else
		{
			exposant = 0;
		}

		mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
	}
	else
	{
		tampon_entier = *((integer8 *) valeur_numerique);

		if (tampon_entier > ((integer8) 0))
		{
			exposant = (long) floor(log10(tampon_entier));
		}
		else if (tampon_entier < ((integer8) 0))
		{
			exposant = (long) floor(log10(-tampon_entier));
		}
		else
		{
			exposant = 0;
		}

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

	longueur_utile = longueur;
	longueur_utile_limite = 15;

	if (longueur_utile > longueur_utile_limite)
	{
		longueur_utile = longueur_utile_limite;
	}

	if (format_sortie == 'S')
	{
		strcpy(mode, "STD");
	}
	else if (format_sortie == 'C')
	{
		strcpy(mode, "SCI");
	}
	else if (format_sortie == 'F')
	{
		strcpy(mode, "FIX");
	}
	else
	{
		strcpy(mode, "ENG");
	}

	if ((strcmp(mode, "SCI") == 0) ||
			((strcmp(mode, "STD") == 0) && ((exposant >
			longueur_utile_limite) ||
			(exposant < -longueur_utile_limite))) ||
			((strcmp(mode, "FIX") == 0) &&
			((exposant >= longueur_utile_limite) ||
			(exposant < -longueur_utile))))
	{
		chaine[0] = 0;
		format[0] = 0;

		if (strcmp(mode, "STD") == 0)
		{
			longueur_utile = longueur_utile_limite - 1;
		}

		sprintf(format, "%%.%luf", longueur_utile);
			
		sprintf(tampon, format, mantisse);
		strcpy(chaine, tampon);
		strcat(chaine, "E");
		sprintf(tampon, "%ld", exposant);
		strcat(chaine, tampon);
	}
	else if (strcmp(mode, "FIX") == 0)
	{
		chaine[0] = 0;
		format[0] = 0;

		if (longueur_utile + exposant >= longueur_utile_limite)
		{
			longueur_utile = longueur_utile_limite - (exposant + 1);
		}

		sprintf(format, "%%.%luf", longueur_utile);

		sprintf(tampon, format, (mantisse * pow(10, exposant)));
		strcpy(chaine, tampon);
	}
	else if (strcmp(mode, "ENG") == 0)
	{
		chaine[0] = 0;
		format[0] = 0;

		correction = labs(exposant) % 3;

		if (exposant < 0)
		{
			if (correction == 0)
			{
				correction = 3;
			}

			correction =  3 - correction;
		}

		longueur_utile -= correction;
		sprintf(format, "%%.%luf", longueur_utile);

		sprintf(tampon, format, (mantisse * pow(10, correction)));
		strcpy(chaine, tampon);
		strcat(chaine, "E");
		sprintf(tampon, "%ld", (exposant - correction));
		strcat(chaine, tampon);
	}
	else
	{
		if (type == 'I')
		{
			chaine[0] = 0;
			sprintf(tampon, "%lld", *((integer8 *) valeur_numerique));
		}
		else
		{
			chaine[0] = 0;
			format[0] = 0;

			if (exposant >= 0)
			{
				sprintf(format, "%%.%luf", (longueur_utile_limite - exposant
						- 1));
			}
			else
			{
				sprintf(format, "%%.%luf", longueur_utile_limite);
			}

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

			i = strlen(tampon) - 1;
			while(tampon[i] == '0')
			{
				tampon[i] = 0;
				i--;
			}

			if (ds_imposition_separateur_decimal == d_faux)
			{
				i = strlen(tampon) - 1;
				if (tampon[i] == '.')
				{
					tampon[i] = 0;
				}
			}
		}
		strcpy(chaine, tampon);
	}

	if (longueur_champ >= 0)
	{
		if (strlen(chaine) > (size_t) longueur_champ)
		{
			for(i = 0; i < (unsigned long) longueur_champ; i++)
			{
				chaine[i] = '*';
			}

			chaine[i] = d_code_fin_chaine;
		}
	}

	return(chaine);
}


/*
--------------------------------------------------------------------------------
  Mêmes fonctions mais pour les fichiers binaires
--------------------------------------------------------------------------------
*/

unsigned char *
formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
		void *valeur_numerique, unsigned char type, long longueur,
		long *longueur_conversion)
{
	unsigned char				*chaine;

	switch(type)
	{
		default :
		case 'I' :
		{
			switch(longueur)
			{
				case 1:
				{
					if ((*((integer8 *) valeur_numerique)) !=
							((integer1) (*((integer8 *) valeur_numerique))))
					{
						(*s_etat_processus).erreur_execution =
								d_ex_representation;
						return(NULL);
					}

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

					(*longueur_conversion) = 2;
					chaine[0] = 0x10;
					chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;
					break;
				}

				case 2:
				{
					if ((*((integer8 *) valeur_numerique)) !=
							((integer2) (*((integer8 *) valeur_numerique))))
					{
						(*s_etat_processus).erreur_execution =
								d_ex_representation;
						return(NULL);
					}

					if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					(*longueur_conversion) = 3;
					chaine[0] = 0x11;
					chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)
							& 0xFF;
					chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;
					break;
				}

				case 4:
				{
					if ((*((integer8 *) valeur_numerique)) !=
							((integer2) (*((integer8 *) valeur_numerique))))
					{
						(*s_etat_processus).erreur_execution =
								d_ex_representation;
						return(NULL);
					}

					if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					(*longueur_conversion) = 5;
					chaine[0] = 0x12;
					chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)
							& 0xFF;
					chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)
							& 0xFF;
					chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)
							& 0xFF;
					chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;
					break;
				}

				case 8:
				{
					if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					(*longueur_conversion) = 9;
					chaine[0] = 0x13;
					chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)
							& 0xFF;
					chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)
							& 0xFF;
					chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)
							& 0xFF;
					chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)
							& 0xFF;
					chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)
							& 0xFF;
					chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)
							& 0xFF;
					chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)
							& 0xFF;
					chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;
					break;
				}

				default :
				{
					(*s_etat_processus).erreur_execution =
							d_ex_erreur_format_fichier;
					return(NULL);
				}
			}

			break;
		}

		case 'R' :
		{
			switch(longueur)
			{
				case 4:
				{
					double			vinf;
					double			vsup;

					union
					{
						real4		r4;
						integer4	i4;
					}				eq4;

					if ((*((real8 *) valeur_numerique)) > 0)
					{
						vinf = nextafter((*((real8 *) valeur_numerique)), 0);
						vsup = nextafter((*((real8 *) valeur_numerique)),
								(*((real8 *) valeur_numerique)) * 2);
					}
					else
					{
						vinf = nextafter((*((real8 *) valeur_numerique)),
								(*((real8 *) valeur_numerique)) * 2);
						vsup = nextafter((*((real8 *) valeur_numerique)), 0);
					}

					if (!((vinf <= ((real4) (*((real8 *) valeur_numerique)))) &&
							((real4) ((*((real8 *) valeur_numerique)))
							<= vsup)))
					{
						(*s_etat_processus).erreur_execution =
								d_ex_representation;
						return(NULL);
					}

					if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					eq4.r4 = (real4) (*((real8 *) valeur_numerique));
					(*longueur_conversion) = 5;
					chaine[0] = 0x12;
					chaine[1] = (eq4.i4 >> 24) & 0xFF;
					chaine[2] = (eq4.i4 >> 16) & 0xFF;
					chaine[3] = (eq4.i4 >> 8) & 0xFF;
					chaine[4] = eq4.i4 & 0xFF;
					break;
				}

				case 8:
				{
					union
					{
						real8		r8;
						integer8	i8;
					}				eq8;

					if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
					{
						(*s_etat_processus).erreur_systeme =
								d_es_allocation_memoire;
						return(NULL);
					}

					eq8.r8 = (*((real8 *) valeur_numerique));

					(*longueur_conversion) = 9;
					chaine[0] = 0x13;
					chaine[1] = (eq8.i8 >> 56) & 0xFF;
					chaine[2] = (eq8.i8 >> 48) & 0xFF;
					chaine[3] = (eq8.i8 >> 40) & 0xFF;
					chaine[4] = (eq8.i8 >> 32) & 0xFF;
					chaine[5] = (eq8.i8 >> 24) & 0xFF;
					chaine[6] = (eq8.i8 >> 16) & 0xFF;
					chaine[7] = (eq8.i8 >> 8) & 0xFF;
					chaine[8] = eq8.i8 & 0xFF;
					break;
				}

				default :
				{
					(*s_etat_processus).erreur_execution =
							d_ex_erreur_format_fichier;
					return(NULL);
				}
			}

			break;
		}

		case 'C' :
		{
			switch(longueur)
			{
				case 8:
				{
					unsigned char		*partie_reelle;
					unsigned char		*partie_imaginaire;

					long				limag;
					long				lreel;

					if ((partie_reelle = formateur_fichier_binaire_nombre(
							s_etat_processus, &((*((complex16 *)
							valeur_numerique)).partie_reelle), 'R', 4, &lreel))
							== NULL)
					{
						return(NULL);
					}

					if ((partie_imaginaire = formateur_fichier_binaire_nombre(
							s_etat_processus, &((*((complex16 *)
							valeur_numerique)).partie_imaginaire), 'R', 4,
							&limag)) == NULL)
					{
						free(partie_reelle);
						return(NULL);
					}

					if ((chaine = malloc((lreel + limag - 1) *
							sizeof(unsigned char))) == NULL)
					{
						free(partie_reelle);
						free(partie_imaginaire);

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

					chaine[0] = 0x18;
					memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
					memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
					(*longueur_conversion) = lreel + limag - 1;

					free(partie_reelle);
					free(partie_imaginaire);
					break;
				}

				case 16:
				{
					unsigned char		*partie_reelle;
					unsigned char		*partie_imaginaire;

					long				limag;
					long				lreel;

					if ((partie_reelle = formateur_fichier_binaire_nombre(
							s_etat_processus, &((*((complex16 *)
							valeur_numerique)).partie_reelle), 'R', 8, &lreel))
							== NULL)
					{
						return(NULL);
					}

					if ((partie_imaginaire = formateur_fichier_binaire_nombre(
							s_etat_processus, &((*((complex16 *)
							valeur_numerique)).partie_imaginaire), 'R', 8,
							&limag)) == NULL)
					{
						free(partie_reelle);
						return(NULL);
					}

					if ((chaine = malloc((lreel + limag - 1) *
							sizeof(unsigned char))) == NULL)
					{
						free(partie_reelle);
						free(partie_imaginaire);

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

					chaine[0] = 0x19;
					memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
					memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
					(*longueur_conversion) = lreel + limag - 1;

					free(partie_reelle);
					free(partie_imaginaire);
					break;
				}

				default :
				{
					(*s_etat_processus).erreur_execution =
							d_ex_erreur_format_fichier;
					return(NULL);
				}
			}

			break;
		}
	}

	return(chaine);
}