/* ================================================================================ RPL/2 (R) version 4.1.20 Copyright (C) 1989-2015 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, integer8 longueur, integer8 longueur_champ, unsigned char format_sortie, unsigned char type, integer8 *longueur_effective, integer8 *recursivite, logical1 export_fichier) { /* * 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)" * "native*(*)" } * * 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*n" "character*(*)" "native*(*)" } */ 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_format_tmp; 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 char type_binaire; integer8 i; integer8 j; integer8 nombre_arguments; integer8 nombre_arguments_fonction; integer8 nombre_colonnes; integer8 nombre_elements; integer8 nombre_lignes; integer8 longueur_chaine_traitee; integer8 longueur_fonction; integer8 longueur_liste; integer8 longueur_reelle_chaine; integer8 longueur_totale; 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, " "); if ((*s_objet).type == ALG) { /* -------------------------------------------------------------------------------- Expression algébrique -------------------------------------------------------------------------------- */ if (format_sortie != 'N') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } 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; (*s_etat_processus).type_en_cours = NON; 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) || (strcmp(chaine_fonction, "EQV") == 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) || (strcmp(chaine_fonction, "EQV") == 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); (*s_etat_processus).type_en_cours = NON; 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) || (strcmp(chaine_fonction, "EQV") == 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) || (strcmp(chaine_fonction, "EQV") == 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) || (strcmp((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction, "EQV") == 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, export_fichier)) == 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 = ((integer8) 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') && (format_sortie != 'N')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } if (format_sortie == 'N') { sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *) ((*s_objet).objet)))); strcpy(base, "h"); } else { switch(longueur) { case 2: { sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *) ((*s_objet).objet)))); 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 < ((integer8) 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"); break; } case 8: { sprintf(tampon, "%llo", (*((unsigned long long *) ((*s_objet).objet)))); strcpy(base, "o"); break; } case 10: { sprintf(tampon, "%llu", (*((unsigned long long *) ((*s_objet).objet)))); strcpy(base, "d"); break; } case 16: { sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *) ((*s_objet).objet)))); strcpy(base, "h"); break; } default: { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } } } if (format_sortie == 'B') { if ((longueur_champ > 0) && (longueur_champ < (signed) strlen(tampon))) { ptrl = &(tampon[((integer8) strlen(tampon)) - longueur_champ]); ptre = tampon; do { *ptre++ = *ptrl++; } while((*ptrl) != d_code_fin_chaine); (*ptre) = d_code_fin_chaine; } } 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') && (format_sortie != 'N')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } longueur_reelle_chaine = longueur_chaine(s_etat_processus, (unsigned char *) (*s_objet).objet); if (format_sortie == 'N') { longueur_champ = -1; } if ((longueur_champ == -1) || (longueur_reelle_chaine < 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 { longueur_reelle_chaine = pointeur_ieme_caractere( s_etat_processus, (unsigned char *) (*s_objet).objet, longueur_champ) - ((unsigned char *) (*s_objet).objet); if ((chaine = malloc((((size_t) longueur_reelle_chaine) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strncpy(chaine, (unsigned char *) ((*s_objet).objet), (size_t) longueur_reelle_chaine); chaine[longueur_reelle_chaine] = d_code_fin_chaine; } } else if ((*s_objet).type == CPL) { /* -------------------------------------------------------------------------------- Complexe -------------------------------------------------------------------------------- */ if (format_sortie == 'N') { format_sortie = 'S'; } 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 -------------------------------------------------------------------------------- */ if (format_sortie != 'N') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } 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, export_fichier)) == 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 == 'N') { format_sortie = 'S'; } 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 -------------------------------------------------------------------------------- */ if (format_sortie != 'N') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } 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 (format_sortie != 'N') { if ((chaine_formatee = formateur_fichier(s_etat_processus, (*l_element_courant).donnee, (*l_element_courant_format).donnee, 0, 0, ' ', 'F', longueur_effective, recursivite, export_fichier)) == NULL) { return(NULL); } } else { if ((chaine_formatee = formateur_fichier(s_etat_processus, (*l_element_courant).donnee, (*l_element_courant_format).donnee, 0, 0, 'N', 'F', longueur_effective, recursivite, export_fichier)) == 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( s_etat_processus, (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 if (strcmp("NATIVE*(*)", format_chaine) == 0) { format_sortie = 'N'; position_1 = 7; format_degenere = d_vrai; } else { free(chaine); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } position_3 = ((integer8) strlen(format_chaine)) - 1; if (format_chaine[position_3] != ')') { free(chaine); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } 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]), "%lld", &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]), "%lld", &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) && (format_sortie != 'B')) { free(chaine); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } free(format_chaine); chaine_sauvegarde = chaine; // Si le format_sortie vaut 'N', on remplace le format par // { "native*(*)" }. L'intérêt est de pouvoir traiter une // liste par un format "native*(*)". if ((format_sortie == 'N') && ((*(*l_element_courant) .donnee).type == LST)) { if ((s_format_tmp = allocation(s_etat_processus, LST)) == NULL) { return(NULL); } if (((*s_format_tmp).objet = allocation_maillon( s_etat_processus)) == NULL) { return(NULL); } (*((struct_liste_chainee *) (*s_format_tmp).objet)) .suivant = NULL; if (((*((struct_liste_chainee *) (*s_format_tmp).objet)) .donnee = allocation(s_etat_processus, CHN)) == NULL) { return(NULL); } if (((*(*((struct_liste_chainee *) (*s_format_tmp) .objet)).donnee).objet = malloc(11 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy((unsigned char *) (*(*((struct_liste_chainee *) (*s_format_tmp).objet)).donnee).objet, "native*(*)"); } else { if ((s_format_tmp = copie_objet(s_etat_processus, s_format, 'P')) == NULL) { return(NULL); } } if ((chaine_formatee = formateur_fichier(s_etat_processus, (*l_element_courant).donnee, s_format, longueur, longueur_champ, format_sortie, type, longueur_effective, recursivite, export_fichier)) == NULL) { liberation(s_etat_processus, s_format_tmp); free(chaine); return(NULL); } liberation(s_etat_processus, s_format_tmp); 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; if (format_sortie != 'N') { l_element_courant_format = (*l_element_courant_format).suivant; } } // Dans le cas où le format de sortie n'est pas du type // NATIVE*(*), on vérifie que tous les éléments du format et // de la liste d'arguments ont été consommés. if (format_sortie != 'N') { 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) && (format_sortie != 'N')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } if (format_sortie != 'N') { 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 (format_sortie != 'N') { 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, (*(*((struct_tableau *) (*s_objet).objet)) .elements[i]).objet, (*(*((struct_tableau *) (*s_format).objet)) .elements[i]).objet, 0, 0, ' ', 'F', longueur_effective, recursivite, export_fichier)) == NULL) { return(NULL); } if ((chaine = (unsigned char *) malloc((strlen( chaine_formatee) + strlen(chaine_sauvegarde) + 2) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy(chaine, chaine_sauvegarde); free(chaine_sauvegarde); strcat(chaine, " "); 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( s_etat_processus, (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 if (strcmp("NATIVE*(*)", format_chaine) == 0) { format_sortie = 'N'; position_1 = 7; format_degenere = d_vrai; } else { free(chaine); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } position_3 = (integer8) 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]), "%lld", &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]), "%lld", &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, export_fichier)) == NULL) { return(NULL); } } } else // NATIVE*(*) { 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, export_fichier)) == 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 == 'N') { format_sortie = 'S'; } 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 == 'N') { format_sortie = 'S'; } 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 == 'N') { format_sortie = 'S'; } 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 -------------------------------------------------------------------------------- */ if (format_sortie != 'N') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } 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 == 'N') { format_sortie = 'S'; } 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 == 'N') { format_sortie = 'S'; } 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 == 'N') { format_sortie = 'S'; } 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 == 'N') { format_sortie = 'S'; } 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) = ((integer8) 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) * * XXXXXXX0 longueur sur 7 bits * XXXX0011 XXXXXXXX XXXX0011 longueur sur 16 bits * LSB(1/2) MSB LSB(2/2) * XXXX0101 XXXXXXXX XXXXXXXX XXXX0101 longueur sur 24 bits * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX * XXXX0111 longueur sur 32 bits * XXXX1001 XXXXXXXX XXXXXXXX XXXXXXXX * XXXXXXXX XXXX1001 longueur sur 40 bits * XXXX1011 XXXXXXXX XXXXXXXX XXXXXXXX * XXXXXXXX XXXXXXXX XXXX1011 longueur sur 48 bits * XXXX1101 XXXXXXXX XXXXXXXX XXXXXXXX * XXXXXXXX XXXXXXXX XXXXXXXX * XXXX1101 longueur sur 56 bits * XXXX1111 XXXXXXXX XXXXXXXX XXXXXXXX * XXXXXXXX XXXXXXXX XXXXXXXX * XXXXXXXX XXXX1111 longueur sur 64 bits * * 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) * * 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 * 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; if ((*s_objet).type == BIN) { /* -------------------------------------------------------------------------------- Entier binaire en base 2, 8, 10 ou 16 Poids fort 0000 -------------------------------------------------------------------------------- */ if (format_sortie == 'N') { format_sortie = 'L'; longueur_champ = 8; } if (format_sortie != 'L') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } if (longueur_champ < 8) { if ((*((logical8 *) (*s_objet).objet)) >= ((logical8) 1 << (8 * longueur_champ))) { (*s_etat_processus).erreur_execution = d_ex_representation; return(NULL); } } (*longueur_effective) = longueur_champ + 1; if ((chaine = malloc(((size_t) (*longueur_effective)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) longueur_champ; for(i = 1; i <= (*longueur_effective); i++) { chaine[i] = ((*((logical8 *) (*s_objet).objet)) >> (8 * (longueur_champ - i))) & 0xFF; } } else if ((*s_objet).type == CHN) { /* -------------------------------------------------------------------------------- Chaîne de caractères Poids fort 1000 0XXX (longueur inférieure à 2**3-1 1000 10LL (autres longueurs) -------------------------------------------------------------------------------- */ if (format_sortie == 'N') { format_sortie = 'S'; longueur_champ = -1; } if (format_sortie != 'S') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } longueur_reelle_chaine = longueur_chaine(s_etat_processus, (unsigned char *) (*s_objet).objet); if ((longueur_champ == -1) || (longueur_reelle_chaine < longueur_champ)) { // Le format est CHARACTER*(*). On copie dans la sortie // la chaine en évaluant les caractères échappés. if ((chaine = formateur_flux(s_etat_processus, (unsigned char *) (*s_objet).objet, &longueur_chaine_traitee)) == NULL) { return(NULL); } } else { // Format de type CHARACTER*(n) if ((chaine_sauvegarde = formateur_flux(s_etat_processus, (unsigned char *) (*s_objet).objet, &longueur_chaine_traitee)) == NULL) { return(NULL); } if ((chaine = malloc(((size_t) longueur_champ) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ); longueur_chaine_traitee = longueur_champ; free(chaine_sauvegarde); } chaine_sauvegarde = chaine; if (longueur_chaine_traitee < (1LL << 3)) { if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (0x80 | (longueur_chaine_traitee & 0x7)); memcpy(chaine + 1, chaine_sauvegarde, (size_t) longueur_chaine_traitee); longueur_totale = longueur_chaine_traitee + 1; } else if (longueur_chaine_traitee < (1LL << 8)) { if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) 0x88; chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF); memcpy(chaine + 2, chaine_sauvegarde, (size_t) longueur_chaine_traitee); longueur_totale = longueur_chaine_traitee + 2; } else if (longueur_chaine_traitee < (1LL << 16)) { if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) 0x89; chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8) & 0xFF); chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF); memcpy(chaine + 3, chaine_sauvegarde, (size_t) longueur_chaine_traitee); longueur_totale = longueur_chaine_traitee + 3; } else if (longueur_chaine_traitee < (1LL << 32)) { if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) 0x8A; chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24) & 0xFF); chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16) & 0xFF); chaine[3] = (unsigned char) ((longueur_chaine_traitee >> 8) & 0xFF); chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF); memcpy(chaine + 5, chaine_sauvegarde, (size_t) longueur_chaine_traitee); longueur_totale = longueur_chaine_traitee + 5; } else { if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) 0x8B; chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56) & 0xFF); chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48) & 0xFF); chaine[3] = (unsigned char) ((longueur_chaine_traitee >> 40) & 0xFF); chaine[4] = (unsigned char) ((longueur_chaine_traitee >> 32) & 0xFF); chaine[5] = (unsigned char) ((longueur_chaine_traitee >> 24) & 0xFF); chaine[6] = (unsigned char) ((longueur_chaine_traitee >> 16) & 0xFF); chaine[7] = (unsigned char) ((longueur_chaine_traitee >> 8) & 0xFF); chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF); memcpy(chaine + 9, chaine_sauvegarde, (size_t) longueur_chaine_traitee); longueur_totale = longueur_chaine_traitee + 9; } (*longueur_effective) = longueur_totale; } else if ((*s_objet).type == CPL) { /* -------------------------------------------------------------------------------- Complexe Poids fort 0001 10 -------------------------------------------------------------------------------- */ if (format_sortie == 'N') { format_sortie = 'C'; longueur = 8; } 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', 'C', longueur, longueur_effective)) == NULL) { return(NULL); } } else if ((*s_objet).type == INT) { /* -------------------------------------------------------------------------------- Entier Poids fort 0001 00 -------------------------------------------------------------------------------- */ if (format_sortie == 'N') { format_sortie = 'I'; longueur = 8; } if ((format_sortie != 'I') && (format_sortie != 'R') && (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, 'I', format_sortie, longueur, longueur_effective)) == NULL) { return(NULL); } } else if ((*s_objet).type == FCT) { /* -------------------------------------------------------------------------------- Fonction Poids fort 1110 -------------------------------------------------------------------------------- */ if (format_sortie != 'N') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } longueur_fonction = (integer8) strlen((*((struct_fonction *) (*s_objet).objet)).nom_fonction); if (longueur_fonction < (1LL << 3)) { if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7)); strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet)) .nom_fonction); (*longueur_effective) = 1 + longueur_fonction + 8; } else if (longueur_fonction < (1LL << 8)) { if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (0xE0 | 0x08); chaine[1] = (unsigned char) (longueur_fonction & 0xFF); strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet)) .nom_fonction); (*longueur_effective) = 2 + longueur_fonction + 8; } else if (longueur_fonction < (1LL << 16)) { if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char ) (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); (*longueur_effective) = 3 + longueur_fonction + 9; } else if (longueur_fonction < (1LL << 32)) { if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (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); (*longueur_effective) = 5 + longueur_fonction + 8; } else { if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (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); (*longueur_effective) = 9 + longueur_fonction + 8; } for(i = 1; i <= 8; i++) { chaine[(*longueur_effective) - i] = (unsigned char) (((*((struct_fonction *) (*s_objet).objet)) .nombre_arguments >> ((8 - i) * 8)) & 0xFF); } } else if (((*s_objet).type == LST) || ((*s_objet).type == ALG) || ((*s_objet).type == RPN)) { /* -------------------------------------------------------------------------------- Liste Poids fort 0100 Expression algébrique Poids fort 0111 Définition Poids fort 0110 -------------------------------------------------------------------------------- */ chaine = malloc(sizeof(unsigned char)); if (chaine == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if ((*s_objet).type == LST) { type_binaire = 0x40; } else if ((*s_objet).type == RPN) { type_binaire = 0x60; } else // ALG { type_binaire = 0x70; } // 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] = (unsigned char) (type_binaire | (longueur_liste & 0x7)); } else if (longueur_liste < (1LL << 8)) { chaine[0] = (unsigned char) (type_binaire | 0x08); } else if (longueur_liste < (1LL << 16)) { chaine[0] = (unsigned char ) (type_binaire | 0x09); } else if (longueur_liste < (1LL << 32)) { chaine[0] = (unsigned char) (type_binaire | 0x0A); } else { chaine[0] = (unsigned char) (type_binaire | 0x0B); } longueur_totale = 1; if ((chaine[0] & 0x8) != 0) { switch(chaine[0] & 0x03) { case 0x00 : { longueur_totale += 1; if ((chaine = realloc(chaine, ((size_t) 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, ((size_t) 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, ((size_t) 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, ((size_t) 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 (format_sortie != 'N') { if ((chaine_formatee = formateur_fichier( s_etat_processus, (*l_element_courant).donnee, (*l_element_courant_format).donnee, 0, 0, ' ', 'U', longueur_effective, recursivite, export_fichier)) == NULL) { return(NULL); } } else { if ((chaine_formatee = formateur_fichier( s_etat_processus, (*l_element_courant).donnee, (*l_element_courant_format).donnee, 0, 0, 'N', 'U', longueur_effective, recursivite, export_fichier)) == NULL) { return(NULL); } } if ((chaine = realloc(chaine, ((size_t) (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, (size_t) (*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( s_etat_processus, (unsigned char *) (*(*l_element_courant_format).donnee).objet)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } 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 (strncmp("CHARACTER*", format_chaine, 10) == 0) { format_sortie = 'S'; position_1 = 10; format_degenere = d_vrai; } else if (strcmp("NATIVE*(*)", format_chaine) == 0) { format_sortie = 'N'; position_1 = 7; format_degenere = d_vrai; } else { free(chaine); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } 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 (strcmp(&(format_chaine[position_1]), "(*)") != 0) { if (sscanf(&(format_chaine[position_1]), "%lld", &longueur) != 1) { free(chaine); free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } longueur_champ = longueur; } else { longueur_champ = -1; longueur = -1; } free(format_chaine); // Si le format_sortie vaut 'N', on remplace le format par // { "native*(*)" }. L'intérêt est de pouvoir traiter une // liste par un format "native*(*)". if ((format_sortie == 'N') && ((*(*l_element_courant) .donnee).type == LST)) { if ((s_format_tmp = allocation(s_etat_processus, LST)) == NULL) { return(NULL); } if (((*s_format_tmp).objet = allocation_maillon( s_etat_processus)) == NULL) { return(NULL); } (*((struct_liste_chainee *) (*s_format_tmp).objet)) .suivant = NULL; if (((*((struct_liste_chainee *) (*s_format_tmp).objet)) .donnee = allocation(s_etat_processus, CHN)) == NULL) { return(NULL); } if (((*(*((struct_liste_chainee *) (*s_format_tmp) .objet)).donnee).objet = malloc(11 * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } strcpy((unsigned char *) (*(*((struct_liste_chainee *) (*s_format_tmp).objet)).donnee).objet, "native*(*)"); } else { if ((s_format_tmp = copie_objet(s_etat_processus, s_format, 'P')) == NULL) { return(NULL); } } if ((chaine_formatee = formateur_fichier(s_etat_processus, (*l_element_courant).donnee, s_format_tmp, longueur, longueur_champ, format_sortie, type, longueur_effective, recursivite, export_fichier)) == NULL) { liberation(s_etat_processus, s_format_tmp); free(chaine); return(NULL); } liberation(s_etat_processus, s_format_tmp); if ((chaine = realloc(chaine, ((size_t) (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, (size_t) (*longueur_effective)); longueur_totale += (*longueur_effective); free(chaine_formatee); } if (format_sortie != 'N') { l_element_courant_format = (*l_element_courant_format).suivant; } nombre_elements++; l_element_courant = (*l_element_courant).suivant; } if (format_sortie != 'N') { if ((l_element_courant != NULL) || (l_element_courant_format != NULL)) { free(chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } } (*longueur_effective) = longueur_totale; } else if ((*s_objet).type == TBL) { /* -------------------------------------------------------------------------------- Table -------------------------------------------------------------------------------- */ } else if ((*s_objet).type == MCX) { /* -------------------------------------------------------------------------------- Matrice complexe -------------------------------------------------------------------------------- */ } else if ((*s_objet).type == MIN) { /* -------------------------------------------------------------------------------- Matrice entière -------------------------------------------------------------------------------- */ } else if ((*s_objet).type == MRL) { /* -------------------------------------------------------------------------------- Matrice réelle -------------------------------------------------------------------------------- */ } else if ((*s_objet).type == NOM) { /* -------------------------------------------------------------------------------- Nom Poids fort 0101 -------------------------------------------------------------------------------- */ if (format_sortie != 'N') { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } longueur_fonction = (integer8) strlen((*((struct_nom *) (*s_objet).objet)).nom); if (longueur_fonction < (1LL << 3)) { if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (0x50 | (longueur_fonction & 0x7)); strcpy(chaine + 1, (*((struct_nom *) (*s_objet).objet)).nom); (*longueur_effective) = longueur_fonction + 2; } else if (longueur_fonction < (1LL << 8)) { if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 1) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (0x50 | 0x08); chaine[1] = (unsigned char) (longueur_fonction & 0xFF); strcpy(chaine + 2, (*((struct_nom *) (*s_objet).objet)).nom); (*longueur_effective) = longueur_fonction + 3; } else if (longueur_fonction < (1LL << 16)) { if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (0x50 | 0x09); chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF); chaine[2] = (unsigned char) (longueur_fonction & 0xFF); strcpy(chaine + 3, (*((struct_nom *) (*s_objet).objet)).nom); (*longueur_effective) = longueur_fonction + 4; } else if (longueur_fonction < (1LL << 32)) { if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (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_nom *) (*s_objet).objet)).nom); (*longueur_effective) = longueur_fonction + 6; } else { if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1) * sizeof(unsigned char)))== NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } chaine[0] = (unsigned char) (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_nom *) (*s_objet).objet)).nom); (*longueur_effective) = longueur_fonction + 10; } chaine[(*longueur_effective) - 1] = ((*((struct_nom *) (*s_objet).objet)).symbole == d_vrai) ? 0xFF : 0x00; } else if ((*s_objet).type == REL) { /* -------------------------------------------------------------------------------- Réel Poids fort 0001 01 -------------------------------------------------------------------------------- */ if (format_sortie == 'N') { format_sortie = 'R'; longueur = 8; } if ((format_sortie != 'R') && (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, 'R', format_sortie, longueur, longueur_effective)) == NULL) { return(NULL); } } else if ((*s_objet).type == VCX) { /* -------------------------------------------------------------------------------- Vecteur complexe -------------------------------------------------------------------------------- */ } else if ((*s_objet).type == VIN) { /* -------------------------------------------------------------------------------- Vecteur entier -------------------------------------------------------------------------------- */ } else if ((*s_objet).type == VRL) { /* -------------------------------------------------------------------------------- Vecteur réel -------------------------------------------------------------------------------- */ } else { // Type non exportable (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; free(chaine); return(NULL); } // On n'ajoute la longueur de l'enregistrement que dans le cas // où le format est utilisé dans un fichier. if (((*recursivite) == 1) && (export_fichier == d_vrai)) { // Ajout de la longueur totale en fin d'enregistrement. longueur_totale = (*longueur_effective); if (longueur_totale < (((integer8) 1) << 7)) { tampon[0] = (unsigned char) (((longueur_totale + 1) << 1) & 0xFF); if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } // XXXX XXX0 memcpy(&(chaine[longueur_totale]), tampon, 1); longueur_totale += 1; } else { longueur_totale++; // i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) } i = 0; for(;;) { if ((longueur_totale < (((integer8) 1) << (8 * (i + 2)))) || (i == 6)) { // LSB (4 bits de poids fort) tampon[0] = (unsigned char) ((longueur_totale & 0xF0) | 0x1 /* longueur supérieure à 7 bits */ | ((i + 1) << 1)); for(j = 0; j <= i; j++) { tampon[(i - j) + 1] = (unsigned char) ((longueur_totale >> (8 * (j + 1))) & 0xFF); } // LSB (4 bits de poids faible) tampon[i + 2] = (unsigned char) (((longueur_totale & 0x0F) << 4) | 0x1 /* longueur supérieure à 7 bits */ | ((i + 1) << 1)); break; } switch(i) { case 0 : { i = 2; break; } case 2 : { i = 6; break; } } } // i = 0 => +3 (16 bits) // i = 2 => +5 (32 bits) // i = 6 => +9 (64 bits) if ((chaine = realloc(chaine, (((size_t) longueur_totale) + ((i == 0) ? 3 : ((i == 2) ? 5 : 9))) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } memcpy(&(chaine[longueur_totale]), tampon, 3); longueur_totale += 3; } __zone(); (*longueur_effective) = longueur_totale; } } (*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, integer8 longueur, integer8 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, integer8 longueur, integer8 longueur_champ, unsigned char format_sortie) { real8 mantisse; real8 tampon_reel; integer8 i; 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]; 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, (double) exposant); } else { tampon_entier = *((integer8 *) valeur_numerique); if (tampon_entier > ((integer8) 0)) { exposant = (long) floor(log10((double) tampon_entier)); } else if (tampon_entier < ((integer8) 0)) { exposant = (long) floor(log10((double) -tampon_entier)); } else { exposant = 0; } mantisse = ((real8) (*((integer8 *) valeur_numerique))) / pow(10, (double) exposant); } longueur_utile = (long) 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, (double) 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, (double) 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 = (integer8) (strlen(tampon)) - 1; while(tampon[i] == '0') { tampon[i] = 0; i--; } if (ds_imposition_separateur_decimal == d_faux) { i = ((integer8) 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 < 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_entree, unsigned char type, integer8 longueur, integer8 *longueur_conversion) { unsigned char *chaine; switch(type) { case 'I' : { if (type_entree != type) { (*s_etat_processus).erreur_execution = d_ex_representation; return(NULL); } 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] = (unsigned char) 0x10; chaine[1] = (unsigned char) ((*((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] = (unsigned char) 0x11; chaine[1] = ((unsigned char) ((*((integer8 *) valeur_numerique)) >> 8) & 0xFF); chaine[2] = (unsigned char) ((*((integer8 *) valeur_numerique)) & 0xFF); break; } case 4: { if ((*((integer8 *) valeur_numerique)) != ((integer4) (*((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] = (unsigned char) 0x12; chaine[1] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 24) & 0xFF); chaine[2] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 16) & 0xFF); chaine[3] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 8) & 0xFF); chaine[4] = (unsigned char) ((*((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] = (unsigned char) 0x13; chaine[1] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 56) & 0xFF); chaine[2] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 48) & 0xFF); chaine[3] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 40) & 0xFF); chaine[4] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 32) & 0xFF); chaine[5] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 24) & 0xFF); chaine[6] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 16) & 0xFF); chaine[7] = (unsigned char) (((*((integer8 *) valeur_numerique)) >> 8) & 0xFF); chaine[8] = (unsigned char) ((*((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: { real8 valeur; real8 vinf; real8 vsup; union { real4 r4; integer4 i4; } eq4; if (type_entree == 'R') { valeur = (*((real8 *) valeur_numerique)); } else if (type_entree == 'I') { valeur = (real8) (*((integer8 *) valeur_numerique)); } else { (*s_etat_processus).erreur_execution = d_ex_representation; return(NULL); } if (valeur > 0) { vinf = nextafter(valeur, 0); vsup = nextafter(valeur, valeur * 2); } else { vinf = nextafter(valeur, valeur * 2); vsup = nextafter(valeur, 0); } if (!((vinf <= ((real4) valeur)) && (((real4) valeur) <= 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) valeur; (*longueur_conversion) = 5; chaine[0] = (unsigned char) 0x14; chaine[1] = (unsigned char) ((eq4.i4 >> 24) & 0xFF); chaine[2] = (unsigned char) ((eq4.i4 >> 16) & 0xFF); chaine[3] = (unsigned char) ((eq4.i4 >> 8) & 0xFF); chaine[4] = (unsigned char) (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); } if (type_entree == 'I') { eq8.r8 = (real8) (*((integer8 *) valeur_numerique)); } else if (type_entree == 'R') { eq8.r8 = (*((real8 *) valeur_numerique)); } else { (*s_etat_processus).erreur_execution = d_ex_representation; return(NULL); } (*longueur_conversion) = 9; chaine[0] = (unsigned char) (0x15); chaine[1] = (unsigned char) ((eq8.i8 >> 56) & 0xFF); chaine[2] = (unsigned char) ((eq8.i8 >> 48) & 0xFF); chaine[3] = (unsigned char) ((eq8.i8 >> 40) & 0xFF); chaine[4] = (unsigned char) ((eq8.i8 >> 32) & 0xFF); chaine[5] = (unsigned char) ((eq8.i8 >> 24) & 0xFF); chaine[6] = (unsigned char) ((eq8.i8 >> 16) & 0xFF); chaine[7] = (unsigned char) ((eq8.i8 >> 8) & 0xFF); chaine[8] = (unsigned char) (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; integer8 limag; integer8 lreel; real8 zero; if (type_entree == 'I') { if ((partie_reelle = formateur_fichier_binaire_nombre( s_etat_processus, &(*((integer8 *) valeur_numerique)), 'I', 'R', 4, &lreel)) == NULL) { return(NULL); } zero = 0; if ((partie_imaginaire = formateur_fichier_binaire_nombre( s_etat_processus, &zero, 'R', 'R', 4, &limag)) == NULL) { free(partie_reelle); return(NULL); } } else if (type_entree == 'R') { if ((partie_reelle = formateur_fichier_binaire_nombre( s_etat_processus, &(*((real8 *) valeur_numerique)), 'R', 'R', 4, &lreel)) == NULL) { return(NULL); } zero = 0; if ((partie_imaginaire = formateur_fichier_binaire_nombre( s_etat_processus, &zero, 'R', 'R', 4, &limag)) == NULL) { free(partie_reelle); return(NULL); } } else if (type_entree == 'C') { if ((partie_reelle = formateur_fichier_binaire_nombre( s_etat_processus, &((*((complex16 *) valeur_numerique)).partie_reelle), 'R', 'R', 4, &lreel)) == NULL) { return(NULL); } if ((partie_imaginaire = formateur_fichier_binaire_nombre( s_etat_processus, &((*((complex16 *) valeur_numerique)).partie_imaginaire), 'R', 'R', 4, &limag)) == NULL) { free(partie_reelle); return(NULL); } } else { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } if ((chaine = malloc((((size_t) lreel) + ((size_t) 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] = (unsigned char) 0x18; memcpy(chaine + 1, partie_reelle + 1, ((size_t) lreel) - 1); memcpy(chaine + lreel, partie_imaginaire + 1, ((size_t) limag) - 1); (*longueur_conversion) = lreel + limag - 1; free(partie_reelle); free(partie_imaginaire); break; } case 16: { unsigned char *partie_reelle; unsigned char *partie_imaginaire; integer8 limag; integer8 lreel; real8 zero; if (type_entree == 'I') { if ((partie_reelle = formateur_fichier_binaire_nombre( s_etat_processus, &(*((integer8 *) valeur_numerique)), 'I', 'R', 8, &lreel)) == NULL) { return(NULL); } zero = 0; if ((partie_imaginaire = formateur_fichier_binaire_nombre( s_etat_processus, &zero, 'R', 'R', 8, &limag)) == NULL) { free(partie_reelle); return(NULL); } } else if (type_entree == 'R') { if ((partie_reelle = formateur_fichier_binaire_nombre( s_etat_processus, &(*((real8 *) valeur_numerique)), 'R', 'R', 8, &lreel)) == NULL) { return(NULL); } zero = 0; if ((partie_imaginaire = formateur_fichier_binaire_nombre( s_etat_processus, &zero, 'R', 'R', 8, &limag)) == NULL) { free(partie_reelle); return(NULL); } } else if (type_entree == 'C') { if ((partie_reelle = formateur_fichier_binaire_nombre( s_etat_processus, &((*((complex16 *) valeur_numerique)).partie_reelle), 'R', 'R', 8, &lreel)) == NULL) { return(NULL); } if ((partie_imaginaire = formateur_fichier_binaire_nombre( s_etat_processus, &((*((complex16 *) valeur_numerique)).partie_imaginaire), 'R', 'R', 8, &limag)) == NULL) { free(partie_reelle); return(NULL); } } else { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } if ((chaine = malloc((((size_t) lreel) + ((size_t) 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] = (unsigned char) 0x19; memcpy(chaine + 1, partie_reelle + 1, ((size_t) lreel) - 1); memcpy(chaine + lreel, partie_imaginaire + 1, ((size_t) 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; } default : { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } } return(chaine); } /* ================================================================================ Routines de conversion d'un objet binaire en struct_objet * ================================================================================ Entrées : pointeur sur un void *. Si longueur_buffer est strictement inférieur à zéro, il s'agit d'un file * sinon d'un buffer de type unsigned char *. -------------------------------------------------------------------------------- Sorties : pointeur sur un struct_objet nouvellement alloué -------------------------------------------------------------------------------- Effets de bord : néant ================================================================================ */ struct_objet * lecture_fichier_non_formate(struct_processus *s_etat_processus, void *argument, integer8 longueur_buffer, logical1 recursivite) { file *fichier; int j; integer8 i; integer8 longueur; struct_liste_chainee *l_element_courant; struct_objet *s_objet; struct_objet *s_objet_elementaire; unsigned char octets[8]; unsigned char *buffer; unsigned char *flux; unsigned char *ptr; unsigned char type_objet; size_t deplacement; if (longueur_buffer < 0) { fichier = argument; buffer = NULL; ptr = NULL; } else { buffer = (*((unsigned char **) argument)); ptr = buffer; fichier = NULL; } 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); } } switch(type_objet = (octets[0] & 0xF0)) { case 0x00: // Binaire { switch(octets[0] & 0x0F) { case 0x01: // logical*1 { deplacement = 1; break; } case 0x02: // logical*2 { deplacement = 2; break; } case 0x04: // logical*4 { deplacement = 4; break; } case 0x08: // logical*8 { deplacement = 8; break; } default: { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } if (longueur_buffer < 0) { if (fread(octets, (size_t) sizeof(unsigned char), deplacement, fichier) != deplacement) { 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)) >= (ssize_t) deplacement) { for(i = 0; i < (signed) deplacement; i++) { octets[i] = *ptr++; } } else { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } if ((s_objet = allocation(s_etat_processus, BIN)) == NULL) { return(NULL); } (*((logical8 *) (*s_objet).objet)) = 0; for(i = 0; i < (signed) deplacement; i++) { (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i]) << (8 * ((((signed) deplacement) - 1) - i)); } break; } case 0x10: // Scalaire { switch(octets[0] & 0x0C) { case 0x00: // Entier { switch(octets[0] & 0x03) { case 0x00: // integer*1 { deplacement = 1; break; } case 0x01: // integer*2 { deplacement = 2; break; } case 0x02: // integer*4 { deplacement = 4; break; } case 0x03: // integer*8 { deplacement = 8; break; } } if (longueur_buffer < 0) { if (fread(octets, (size_t) sizeof(unsigned char), deplacement, fichier) != deplacement) { 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)) >= (ssize_t) deplacement) { for(i = 0; i < (signed) deplacement; i++) { octets[i] = *ptr++; } } else { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } if ((s_objet = allocation(s_etat_processus, INT)) == NULL) { return(NULL); } // Récupération des données avec extension de signe. { integer1 i1; integer2 i2; integer4 i4; integer8 i8; i1 = 0; i2 = 0; i4 = 0; i8 = 0; for(i = 0; i < (signed) deplacement; i++) { switch(deplacement) { case 1: i1 = (integer1) octets[0]; break; case 2: i2 |= (integer2) (((integer8) octets[i]) << (8 * ((((signed) deplacement) - 1) - i))); break; case 4: i4 |= (integer4) (((integer8) octets[i]) << (8 * ((((signed) deplacement) - 1) - i))); break; case 8: i8 |= (integer8) (((integer8) octets[i]) << (8 * ((((signed) deplacement) - 1) - i))); break; } } switch(deplacement) { case 1: (*((integer8 *) (*s_objet).objet)) = (integer8) i1; break; case 2: (*((integer8 *) (*s_objet).objet)) = (integer8) i2; break; case 4: (*((integer8 *) (*s_objet).objet)) = (integer8) i4; break; case 8: (*((integer8 *) (*s_objet).objet)) = (integer8) i8; break; } } break; } case 0x04: // Réel { switch(octets[0] & 0x03) { case 0x00: // real*4 { deplacement = 4; break; } case 0x01: // real*8 { deplacement = 8; break; } default: { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } if (longueur_buffer < 0) { if (fread(octets, (size_t) sizeof(unsigned char), deplacement, fichier) != deplacement) { 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)) >= (ssize_t) deplacement) { for(i = 0; i < (signed) deplacement; i++) { octets[i] = *ptr++; } } else { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } if ((s_objet = allocation(s_etat_processus, REL)) == NULL) { return(NULL); } if (deplacement == 4) { union { real4 r4; integer4 i4; } eq4; eq4.i4 = 0; for(i = 0; i < (signed) deplacement; i++) { eq4.i4 |= ((integer4) octets[i]) << (8 * ((((signed) deplacement) - 1) - i)); } (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4; } else { union { real8 r8; integer8 i8; } eq8; eq8.i8 = 0; for(i = 0; i < (signed) deplacement; i++) { eq8.i8 |= ((integer8) octets[i]) << (8 * ((((signed) deplacement) - 1) - i)); } (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8; } break; } case 0x08: // Complexe { switch(octets[0] & 0x03) { case 0x00: // complex*8 { deplacement = 4; break; } case 0x01: // complex*16 { deplacement = 8; break; } default: { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } if ((s_objet = allocation(s_etat_processus, CPL)) == NULL) { return(NULL); } for(j = 0; j < 2; j++) { if (longueur_buffer < 0) { if (fread(octets, (size_t) sizeof(unsigned char), deplacement, fichier) != deplacement) { liberation(s_etat_processus, s_objet); 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)) >= (ssize_t) deplacement) { for(i = 0; i < (signed) deplacement; i++) { octets[i] = *ptr++; } } else { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } if (deplacement == 4) { union { real4 r4; integer4 i4; } eq4; eq4.i4 = 0; for(i = 0; i < (signed) deplacement; i++) { eq4.i4 |= ((integer4) octets[i]) << (8 * ((((signed) deplacement) - 1) - i)); } if (j == 0) { (*((complex16 *) (*s_objet).objet)) .partie_reelle = (real8) eq4.r4; } else { (*((complex16 *) (*s_objet).objet)) .partie_imaginaire = (real8) eq4.r4; } } else { union { real8 r8; integer8 i8; } eq8; eq8.i8 = 0; for(i = 0; i < (signed) deplacement; i++) { eq8.i8 |= ((integer8) octets[i]) << (8 * ((((signed) deplacement) - 1) - i)); } if (j == 0) { (*((complex16 *) (*s_objet).objet)) .partie_reelle = (real8) eq8.r8; } else { (*((complex16 *) (*s_objet).objet)) .partie_imaginaire = (real8) eq8.r8; } } } break; } default: { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } break; } case 0x40: // Liste case 0x60: // Expression case 0x70: // Expression algébrique { 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 (type_objet == 0x40) { if ((s_objet = allocation(s_etat_processus, LST)) == NULL) { return(NULL); } } else if (type_objet == 0x60) { if ((s_objet = allocation(s_etat_processus, RPN)) == NULL) { return(NULL); } } else { if ((s_objet = allocation(s_etat_processus, ALG)) == NULL) { return(NULL); } } l_element_courant = NULL; for(i = 0; i < longueur; i++) { // Lecture des éléments de la liste. if (longueur_buffer < 0) { if ((s_objet_elementaire = lecture_fichier_non_formate( s_etat_processus, fichier, longueur_buffer, d_vrai)) == NULL) { liberation(s_etat_processus, s_objet); return(NULL); } } else { if ((s_objet_elementaire = lecture_fichier_non_formate( s_etat_processus, &ptr, longueur_buffer - (ptr - buffer), d_vrai)) == NULL) { liberation(s_etat_processus, s_objet); return(NULL); } } if (l_element_courant == NULL) { if (((*s_objet).objet = allocation_maillon( s_etat_processus)) == NULL) { liberation(s_etat_processus, s_objet_elementaire); liberation(s_etat_processus, s_objet); return(NULL); } l_element_courant = (*s_objet).objet; } else { if (((*l_element_courant).suivant = allocation_maillon( s_etat_processus)) == NULL) { liberation(s_etat_processus, s_objet_elementaire); liberation(s_etat_processus, s_objet); return(NULL); } l_element_courant = (*l_element_courant).suivant; } (*l_element_courant).donnee = s_objet_elementaire; (*l_element_courant).suivant = NULL; } break; } case 0x80: // Chaîne de caractères { 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 (longueur_buffer < 0) { if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (fread(flux, (size_t) sizeof(unsigned char), (size_t) longueur, fichier) != (size_t) longueur) { 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)) < longueur) { (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } flux = ptr; ptr += longueur; } if ((s_objet = allocation(s_etat_processus, CHN)) == NULL) { if (longueur_buffer < 0) { free(flux); } (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (((*s_objet).objet = analyse_flux(s_etat_processus, flux, longueur)) == NULL) { return(NULL); } if (longueur_buffer < 0) { free(flux); } break; } case 0x50: // Nom { 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, NOM)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); } if (((*((struct_nom *) (*s_objet).objet)).nom = malloc((((size_t) 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_nom *) (*s_objet) .objet)).nom, (size_t) sizeof(unsigned char), (size_t) 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), 1, fichier) != 1) { 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 + 1)) { for(j = 0; j < longueur; (*((struct_nom *) (*s_objet).objet)).nom[j] = *ptr++); octets[0] = *ptr++; } else { liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; return(NULL); } } (*((struct_nom *) (*s_objet).objet)).nom[longueur] = d_code_fin_chaine; (*((struct_nom *) (*s_objet).objet)).symbole = (octets[0] == 0xFF) ? d_vrai : d_faux; 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((((size_t) 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), (size_t) 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; return(NULL); } } if ((longueur_buffer < 0) && (recursivite == d_faux)) { // Lecture depuis un fichier, on saute le champ de queue qui contient // la longueur de l'enregistrement. if (fread(octets, (size_t) sizeof(unsigned char), 1, fichier) != 1) { liberation(s_etat_processus, s_objet); if (feof(fichier)) { (*s_etat_processus).erreur_execution = d_ex_syntaxe; } else { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; } return(NULL); } if ((octets[0] & 0x01) != 0) { deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1); if (fread(octets, (size_t) sizeof(unsigned char), deplacement, fichier) != deplacement) { liberation(s_etat_processus, s_objet); if (feof(fichier)) { (*s_etat_processus).erreur_execution = d_ex_syntaxe; } else { (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; } return(NULL); } } } if (longueur_buffer >= 0) { (*((unsigned char **) argument)) = ptr; } return(s_objet); } // vim: ts=4