--- rpl/src/formateur_fichiers.c	2013/03/18 15:53:48	1.57
+++ rpl/src/formateur_fichiers.c	2013/03/19 11:46:11	1.58
@@ -78,7 +78,7 @@ formateur_fichier(struct_processus *s_et
 	logical1					format_degenere;
 	logical1					presence_signe;
 
-	long						longueur_chaine_traitee;
+	unsigned long int			longueur_chaine_traitee;
 
 	struct_liste_chainee		*l_atome;
 	struct_liste_chainee		*l_element_courant;
@@ -111,6 +111,7 @@ formateur_fichier(struct_processus *s_et
 	unsigned long				nombre_elements;
 	unsigned long				nombre_lignes;
 
+	integer8					longueur_fonction;
 	integer8					longueur_liste;
 	integer8					longueur_reelle_chaine;
 	integer8					longueur_totale;
@@ -3031,6 +3032,9 @@ formateur_fichier(struct_processus *s_et
 		 * 1101 10 11				matrice complex*16 (dimensions integer*4)
 		 * 1101 11 11				matrice complex*16 (dimensions integer*8)
 		 *
+		 * 1110 0 XXX				fonction de longueur XXX
+		 * 1110 10 LL				fonction de longueur integer*LL
+		 *
 		 * Les longueurs indiquées par le champ LL suivent l'en-tête :
 		 * 		00 : integer*1
 		 * 		01 : integer*2
@@ -3334,9 +3338,119 @@ formateur_fichier(struct_processus *s_et
 /*
 --------------------------------------------------------------------------------
   Fonction
+  Poids fort 1110
 --------------------------------------------------------------------------------
 */
 
+			if (format_sortie != 'N')
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_format_fichier;
+				return(NULL);
+			}
+
+			longueur_fonction = strlen((*((struct_fonction *) (*s_objet).objet))
+					.nom_fonction);
+
+			if (longueur_fonction < (1LL << 3))
+			{
+				if ((chaine = malloc((1 + longueur_fonction + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xE0 | (longueur_fonction & 0x7);
+
+				strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+			}
+			else if (longueur_fonction < (1LL << 8))
+			{
+				if ((chaine = malloc((2 + longueur_fonction + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xE0 | 0x08;
+				chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+			}
+			else if (longueur_fonction < (1LL << 16))
+			{
+				if ((chaine = malloc((3 + longueur_fonction + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xE0 | 0x09;
+				chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+				chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+			}
+			else if (longueur_fonction < (1LL << 32))
+			{
+				if ((chaine = malloc((5 + longueur_fonction + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xE0 | 0x0A;
+				chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+				chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+			}
+			else
+			{
+				if ((chaine = malloc((9 + longueur_fonction + 8)
+						* sizeof(unsigned char)))== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				chaine[0] = 0xE0 | 0x0B;
+				chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
+				chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
+				chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
+				chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
+				chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
+				chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
+				chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+				chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
+
+				strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction);
+			}
+
+			for(i = 1; i <= 8; i++)
+			{
+				chaine[longueur_fonction + i] = (unsigned char)
+						(((*((struct_fonction *) (*s_objet).objet))
+						.nombre_arguments >> ((8 - i) * 8)) & 0xFF);
+			}
+
+			(*longueur_effective) = longueur_fonction + 9;
 		}
 		else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
 				|| ((*s_objet).type == RPN))
@@ -5743,6 +5857,273 @@ lecture_fichier_non_formate(struct_proce
 			break;
 		}
 
+		case 0xE0:	// Fonction
+		{
+			if ((octets[0] & 0x08) == 0)	// Longueur sur 6 bits
+			{
+				longueur = (octets[0] & 0x07);
+			}
+			else
+			{
+				switch(octets[0] & 0x07)
+				{
+					case 0x00:			// Longueur sur 8 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									1, fichier) != 1)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 1)
+							{
+								octets[0] = *ptr++;
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = octets[0];
+						break;
+					}
+
+					case 0x01:			// Longueur sur 16 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									2, fichier) != 2)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 2)
+							{
+								for(j = 0; j < 2; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 8)
+								| ((integer8) (octets[1]));
+						break;
+					}
+
+					case 0x02:			// Longueur sur 32 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									4, fichier) != 4)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 4)
+							{
+								for(j = 0; j < 4; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 24)
+								| (((integer8) (octets[1])) << 16)
+								| (((integer8) (octets[2])) << 8)
+								| ((integer8) (octets[3]));
+						break;
+					}
+
+					case 0x03:			// Longueur sur 64 bits
+					{
+						if (longueur_buffer < 0)
+						{
+							if (fread(octets, (size_t) sizeof(unsigned char),
+									8, fichier) != 8)
+							{
+								if (feof(fichier))
+								{
+									(*s_etat_processus).erreur_execution =
+											d_ex_syntaxe;
+								}
+								else
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_erreur_fichier;
+								}
+
+								return(NULL);
+							}
+						}
+						else
+						{
+							if ((longueur_buffer - (ptr - buffer)) >= 8)
+							{
+								for(j = 0; j < 8; octets[j++] = *ptr++);
+							}
+							else
+							{
+								(*s_etat_processus).erreur_execution =
+										d_ex_syntaxe;
+								return(NULL);
+							}
+						}
+
+						longueur = (((integer8) (octets[0])) << 56)
+								| (((integer8) (octets[1])) << 48)
+								| (((integer8) (octets[2])) << 40)
+								| (((integer8) (octets[3])) << 32)
+								| (((integer8) (octets[4])) << 24)
+								| (((integer8) (octets[5])) << 16)
+								| (((integer8) (octets[6])) << 8)
+								| ((integer8) (octets[7]));
+						break;
+					}
+
+					default:
+					{
+						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+						return(NULL);
+					}
+				}
+			}
+
+			if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
+					malloc((longueur + 1) * sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return(NULL);
+			}
+
+			if (longueur_buffer < 0)
+			{
+				if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
+						.objet)).nom_fonction, (size_t) sizeof(unsigned char),
+						longueur, fichier) != (unsigned) longueur)
+				{
+					if (feof(fichier))
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_syntaxe;
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+					}
+
+					liberation(s_etat_processus, s_objet);
+					return(NULL);
+				}
+
+				if (fread(octets, (size_t) sizeof(unsigned char),
+						8, fichier) != 8)
+				{
+					if (feof(fichier))
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_syntaxe;
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+					}
+
+					liberation(s_etat_processus, s_objet);
+					return(NULL);
+				}
+			}
+			else
+			{
+				if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8))
+				{
+					for(j = 0; j < longueur; (*((struct_fonction *)
+							(*s_objet).objet)).nom_fonction[j] = *ptr++);
+					for(j = 0; j < 8; octets[j++] = *ptr++);
+				}
+				else
+				{
+					liberation(s_etat_processus, s_objet);
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+					return(NULL);
+				}
+			}
+
+			(*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] =
+					d_code_fin_chaine;
+			(*((struct_fonction *) (*s_objet).objet)).nombre_arguments =
+					(((integer8) (octets[0])) << 56)
+					| (((integer8) (octets[1])) << 48)
+					| (((integer8) (octets[2])) << 40)
+					| (((integer8) (octets[3])) << 32)
+					| (((integer8) (octets[4])) << 24)
+					| (((integer8) (octets[5])) << 16)
+					| (((integer8) (octets[6])) << 8)
+					| ((integer8) (octets[7]));
+			break;
+		}
+
 		default:
 		{
 			(*s_etat_processus).erreur_execution = d_ex_syntaxe;