--- rpl/src/formateur_fichiers.c 2013/03/10 17:01:05 1.52 +++ rpl/src/formateur_fichiers.c 2013/03/16 20:11:29 1.56 @@ -62,7 +62,8 @@ formateur_fichier(struct_processus *s_et * "binary*X(*)" * "binary*X(Y)" (X est la base : 2, 8, 10, 16) * "character*(*)" - * "character*(Y)" } + * "character*(Y)" + * "native*(*)" } * * Traitement du format des fichiers non formatés : * @@ -70,7 +71,7 @@ formateur_fichier(struct_processus *s_et * "real*4", "real*8", ["real*16",] * "complex*8", "complex*16", ["complex*32",] * "logical*1", "logical*2", "logical*4", logical*8", - * "character*n" "character*(*)" } + * "character*n" "character*(*)" "native*(*)" } */ logical1 autorisation_parenthese; @@ -100,6 +101,7 @@ formateur_fichier(struct_processus *s_et unsigned char *ptre; unsigned char *ptrl; unsigned char tampon[64 + 1]; + unsigned char type_binaire; unsigned long i; unsigned long j; @@ -112,7 +114,6 @@ formateur_fichier(struct_processus *s_et integer8 longueur_liste; integer8 longueur_reelle_chaine; integer8 longueur_totale; - integer8 masque_binaire; integer8 position_1; integer8 position_2; integer8 position_3; @@ -131,8 +132,6 @@ formateur_fichier(struct_processus *s_et strcpy(base, " "); - masque_binaire = 0; - if ((*s_objet).type == ALG) { @@ -142,6 +141,13 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + 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) @@ -984,157 +990,180 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ - if (format_sortie != 'B') + if ((format_sortie != 'B') && (format_sortie != 'U')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } - masque_binaire = masque_entiers_binaires(s_etat_processus); - - if ((test_cfsf(s_etat_processus, 43) == d_faux) && - (test_cfsf(s_etat_processus, 44) == d_faux)) + if (format_sortie == 'N') { - -/* --- Base décimale --------------------------------------------------------------- -*/ - - sprintf(tampon, "%llu", (*((logical8 *) - ((*s_objet).objet))) & masque_binaire); - strcpy(base, "d"); + sprintf(tampon, "%llX", (*((logical8 *) + ((*s_objet).objet)))); + strcpy(base, "h"); } - else if ((test_cfsf(s_etat_processus, 43) == d_vrai) && - (test_cfsf(s_etat_processus, 44) == d_faux)) + else { + switch(longueur) + { + case 2: + { + sprintf(tampon, "%llX", (*((logical8 *) + ((*s_objet).objet)))); -/* --- Base octale ----------------------------------------------------------------- -*/ + chaine = (unsigned char *) malloc((strlen(tampon) + 1) + * sizeof(unsigned char)); - sprintf(tampon, "%llo", (*((logical8 *) - ((*s_objet).objet))) & masque_binaire); - strcpy(base, "o"); - } - else if (test_cfsf(s_etat_processus, 44) == d_vrai) - { + if (chaine == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(NULL); + } -/* --- Bases hexadécimale et binaire ----------------------------------------------- -*/ + strcpy(chaine, tampon); + tampon[0] = 0; - sprintf(tampon, "%llX", (*((logical8 *) - ((*s_objet).objet))) & masque_binaire); + for(i = 0; i < strlen(chaine); i++) + { + switch(chaine[i]) + { + case '0' : + { + strcat(tampon, (i != 0) ? "0000" : "0"); + break; + } + case '1' : + { + strcat(tampon, (i != 0) ? "0001" : "1"); + break; + } + case '2' : + { + strcat(tampon, (i != 0) ? "0010" : "10"); + break; + } + case '3' : + { + strcat(tampon, (i != 0) ? "0011" : "11"); + break; + } + case '4' : + { + strcat(tampon, (i != 0) ? "0100" : "100"); + break; + } + case '5' : + { + strcat(tampon, (i != 0) ? "0101" : "101"); + break; + } + case '6' : + { + strcat(tampon, (i != 0) ? "0110" : "110"); + break; + } + case '7' : + { + strcat(tampon, (i != 0) ? "0111" : "111"); + break; + } + case '8' : + { + strcat(tampon, "1000"); + break; + } + case '9' : + { + strcat(tampon, "1001"); + break; + } + case 'A' : + { + strcat(tampon, "1010"); + break; + } + case 'B' : + { + strcat(tampon, "1011"); + break; + } + case 'C' : + { + strcat(tampon, "1100"); + break; + } + case 'D' : + { + strcat(tampon, "1101"); + break; + } + case 'E' : + { + strcat(tampon, "1110"); + break; + } + case 'F' : + { + strcat(tampon, "1111"); + break; + } + } + } - if (test_cfsf(s_etat_processus, 43) == d_vrai) - { - strcpy(base, "h"); - } - else - { - chaine = (unsigned char *) malloc((strlen(tampon) + 1) - * sizeof(unsigned char)); + free(chaine); + strcpy(base, "b"); + break; + } - if (chaine == NULL) + case 8: { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return(NULL); + sprintf(tampon, "%llo", (*((logical8 *) + ((*s_objet).objet)))); + strcpy(base, "o"); + break; } - strcpy(chaine, tampon); - tampon[0] = 0; + case 10: + { + sprintf(tampon, "%llu", (*((logical8 *) + ((*s_objet).objet)))); + strcpy(base, "d"); + break; + } - for(i = 0; i < strlen(chaine); i++) + case 16: { - 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; - } - } + sprintf(tampon, "%llX", (*((logical8 *) + ((*s_objet).objet)))); + strcpy(base, "h"); + break; } - free(chaine); - strcpy(base, "b"); + 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[strlen(tampon) - longueur_champ]); + ptre = tampon; + + do + { + *ptre++ = *ptrl++; + } while((*ptrl) != d_code_fin_chaine); + + (*ptre) = d_code_fin_chaine; } } @@ -1161,7 +1190,7 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ - if (format_sortie != 'C') + if ((format_sortie != 'C') && (format_sortie != 'U')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; @@ -1171,6 +1200,11 @@ formateur_fichier(struct_processus *s_et 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)) { @@ -1215,6 +1249,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -1252,6 +1291,13 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + 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; @@ -1334,6 +1380,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -1371,6 +1422,13 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + 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)); @@ -1418,13 +1476,29 @@ formateur_fichier(struct_processus *s_et { chaine_sauvegarde = chaine; - if ((chaine_formatee = formateur_fichier(s_etat_processus, - (*l_element_courant).donnee, - (*l_element_courant_format).donnee, - 0, 0, ' ', 'F', longueur_effective, recursivite, - export_fichier)) == NULL) + if (format_sortie != 'N') { - return(NULL); + 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) @@ -1497,6 +1571,12 @@ formateur_fichier(struct_processus *s_et 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); @@ -1577,7 +1657,7 @@ formateur_fichier(struct_processus *s_et } if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > - longueur_champ)) + longueur_champ) && (format_sortie != 'B')) { free(chaine); free(format_chaine); @@ -1664,17 +1744,29 @@ formateur_fichier(struct_processus *s_et nombre_elements++; l_element_courant = (*l_element_courant).suivant; - l_element_courant_format = (*l_element_courant_format).suivant; + + if (format_sortie != 'N') + { + l_element_courant_format = + (*l_element_courant_format).suivant; + } } - if ((l_element_courant != NULL) || - (l_element_courant_format != NULL)) + // 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') { - free(chaine); + if ((l_element_courant != NULL) || + (l_element_courant_format != NULL)) + { + free(chaine); - (*s_etat_processus).erreur_execution = - d_ex_erreur_format_fichier; - return(NULL); + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return(NULL); + } } chaine_sauvegarde = chaine; @@ -1700,23 +1792,23 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ - if ((*s_format).type != TBL) + if (((*s_format).type != TBL) && (format_sortie != 'N')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } - l_element_courant = (struct_liste_chainee *) (*s_objet).objet; - l_element_courant_format = (struct_liste_chainee *) - (*s_format).objet; - - if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != - (*((struct_tableau *) (*s_format).objet)).nombre_elements) + if (format_sortie != 'N') { - (*s_etat_processus).erreur_execution = - d_ex_erreur_format_fichier; - return(NULL); + 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)); @@ -1732,115 +1824,108 @@ formateur_fichier(struct_processus *s_et for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) .nombre_elements; i++) { - if ((((*(*((struct_tableau *) (*s_format).objet)) - .elements[i]).type == LST) && - ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) - .type == LST)) || - (((*(*((struct_tableau *) (*s_format).objet)) - .elements[i]).type == TBL) && - ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) - .type == TBL))) + if (format_sortie != 'N') { - chaine_sauvegarde = chaine; - - if ((chaine_formatee = formateur_fichier(s_etat_processus, - (*l_element_courant).donnee, - (*l_element_courant_format).donnee, - 0, 0, ' ', 'F', longueur_effective, recursivite, - export_fichier)) == NULL) - { - return(NULL); - } - - chaine = (unsigned char *) malloc((strlen(chaine_formatee) - + strlen(chaine_sauvegarde) + 2) - * sizeof(unsigned char)); - - if (chaine == NULL) + 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))) { - (*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); + chaine_sauvegarde = chaine; - (*s_etat_processus).erreur_execution = - d_ex_erreur_format_fichier; - return(NULL); - } - else - { - if ((format_chaine = conversion_majuscule((unsigned char *) - (*(*((struct_tableau *) (*s_format).objet)) - .elements[i]).objet)) == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return(NULL); - } + 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); + } - format_degenere = d_faux; + 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); + } - 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; + strcpy(chaine, chaine_sauvegarde); + free(chaine_sauvegarde); + strcat(chaine, " "); + strcat(chaine, chaine_formatee); + free(chaine_formatee); } - else + else if ((*(*((struct_tableau *) (*s_format).objet)) + .elements[i]).type != CHN) { free(chaine); - free(format_chaine); (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; return(NULL); } + else + { + if ((format_chaine = conversion_majuscule( + (unsigned char *) (*(*((struct_tableau *) + (*s_format).objet)).elements[i]).objet)) + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(NULL); + } - position_3 = strlen(format_chaine); - format_chaine[--position_3] = d_code_fin_chaine; - - position_2 = position_1; + format_degenere = d_faux; - while(format_chaine[position_2] != '(') - { - if (format_chaine[position_2] == d_code_fin_chaine) + 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); @@ -1850,33 +1935,66 @@ formateur_fichier(struct_processus *s_et return(NULL); } - position_2++; - } + position_3 = strlen(format_chaine); + format_chaine[--position_3] = d_code_fin_chaine; - format_chaine[position_2++] = d_code_fin_chaine; + position_2 = position_1; - if (format_degenere == d_faux) - { - if (sscanf(&(format_chaine[position_1]), "%ld", - &longueur) != 1) + while(format_chaine[position_2] != '(') { - free(chaine); - free(format_chaine); + 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); + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return(NULL); + } + + position_2++; } - } - else - { - longueur = -1; - } - if (strcmp(&(format_chaine[position_2]), "*") != 0) - { - if (sscanf(&(format_chaine[position_2]), "%ld", - &longueur_champ) != 1) + format_chaine[position_2++] = d_code_fin_chaine; + + if (format_degenere == d_faux) + { + if (sscanf(&(format_chaine[position_1]), "%ld", + &longueur) != 1) + { + free(chaine); + free(format_chaine); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return(NULL); + } + } + else + { + longueur = -1; + } + + if (strcmp(&(format_chaine[position_2]), "*") != 0) + { + if (sscanf(&(format_chaine[position_2]), "%ld", + &longueur_champ) != 1) + { + free(chaine); + free(format_chaine); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return(NULL); + } + } + else + { + longueur_champ = -1; + } + + if ((longueur >= 0) && (longueur_champ >= 0) && + (longueur > longueur_champ)) { free(chaine); free(format_chaine); @@ -1885,98 +2003,97 @@ formateur_fichier(struct_processus *s_et 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); + + chaine_sauvegarde = chaine; - (*s_etat_processus).erreur_execution = - d_ex_erreur_format_fichier; - return(NULL); + 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); + } } - - free(format_chaine); - + } + else // NATIVE*(*) + { chaine_sauvegarde = chaine; - if ((chaine_formatee = formateur_fichier(s_etat_processus, - (*((struct_tableau *) (*s_objet).objet)) - .elements[i], s_format, + 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) + 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); - } + if ((*(*((struct_tableau *) (*s_objet).objet)) + .elements[i]).type == CHN) + { + chaine = (unsigned char *) + malloc((strlen(chaine_formatee) + + strlen(chaine_sauvegarde) + 4) + * sizeof(unsigned char)); - 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) + if (chaine == NULL) { - chaine = (unsigned char *) - malloc((strlen(chaine_formatee) - + strlen(chaine_sauvegarde) + 2) - * sizeof(unsigned char)); + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(NULL); + } - 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)); - sprintf(chaine, "%s %s", chaine_sauvegarde, - chaine_formatee); - free(chaine_formatee); - } - else + if (chaine == NULL) { - chaine = (unsigned char *) - malloc((strlen(chaine_formatee) - + strlen(chaine_sauvegarde) + 2) - * sizeof(unsigned char)); + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(NULL); + } - 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)); - strcpy(chaine, chaine_sauvegarde); - free(chaine_sauvegarde); - strcat(chaine, " "); - strcat(chaine, chaine_formatee); - free(chaine_formatee); + 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); } } @@ -2003,6 +2120,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -2146,6 +2268,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -2288,6 +2415,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -2430,6 +2562,13 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + 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)); @@ -2450,6 +2589,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -2487,6 +2631,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -2563,6 +2712,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -2638,6 +2792,11 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'S'; + } + if ((format_sortie != 'S') && (format_sortie != 'F') && (format_sortie != 'I') && (format_sortie != 'E')) { @@ -2744,7 +2903,7 @@ formateur_fichier(struct_processus *s_et * * XXXXXXX0 longueur sur 7 bits * XXXX0011 XXXXXXXX XXXX0011 longueur sur 16 bits - * MSB(1/2) LSB MSB(2/2) + * LSB(1/2) MSB LSB(2/2) * XXXX0101 XXXXXXXX XXXXXXXX XXXX0101 longueur sur 24 bits * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX * XXXX0111 longueur sur 32 bits @@ -2888,25 +3047,50 @@ formateur_fichier(struct_processus *s_et chaine_formatee = NULL; chaine_sauvegarde = NULL; - if ((*s_objet).type == ALG) + if ((*s_objet).type == BIN) { /* -------------------------------------------------------------------------------- - Expression algébrique + Entier binaire en base 2, 8, 10 ou 16 + Poids fort 0000 -------------------------------------------------------------------------------- */ - } - else if ((*s_objet).type == BIN) - { + if (format_sortie != 'L') + { + (*s_etat_processus).erreur_execution = + d_ex_erreur_format_fichier; + return(NULL); + } -/* --------------------------------------------------------------------------------- - Entier binaire en base 2, 8, 10 ou 16 --------------------------------------------------------------------------------- -*/ + 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((*longueur_effective) * sizeof(unsigned char))) + == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(NULL); + } + + chaine[0] = longueur_champ; + + for(i = 1; i <= (unsigned) (*longueur_effective); i++) + { + chaine[i] = ((*((logical8 *) (*s_objet).objet)) >> + (8 * (longueur_champ - i))) & 0xFF; + } } else if ((*s_objet).type == CHN) { @@ -3088,15 +3272,6 @@ formateur_fichier(struct_processus *s_et return(NULL); } } - else if ((*s_objet).type == RPN) - { - -/* --------------------------------------------------------------------------------- - Définition --------------------------------------------------------------------------------- -*/ - } else if ((*s_objet).type == INT) { @@ -3132,13 +3307,20 @@ formateur_fichier(struct_processus *s_et */ } - else if ((*s_objet).type == LST) + 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 -------------------------------------------------------------------------------- */ @@ -3150,6 +3332,19 @@ formateur_fichier(struct_processus *s_et 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; @@ -3163,23 +3358,23 @@ formateur_fichier(struct_processus *s_et if (longueur_liste < (1LL << 3)) { - chaine[0] = 0x40 | (longueur_liste & 0x7); + chaine[0] = type_binaire | (longueur_liste & 0x7); } else if (longueur_liste < (1LL << 8)) { - chaine[0] = 0x48; + chaine[0] = type_binaire | 0x08; } else if (longueur_liste < (1LL << 16)) { - chaine[0] = 0x49; + chaine[0] = type_binaire | 0x09; } else if (longueur_liste < (1LL << 32)) { - chaine[0] = 0x4A; + chaine[0] = type_binaire | 0x0A; } else { - chaine[0] = 0x4B; + chaine[0] = type_binaire | 0x0B; } longueur_totale = 1; @@ -3591,19 +3786,20 @@ formateur_fichier(struct_processus *s_et if ((longueur_totale < (((integer8) 1) << (8 * (i + 2)))) || (i == 6)) { - // MSB (4 bits de poids fort) - tampon[0] = ((longueur_totale >> 8) & 0xF0) + // LSB (4 bits de poids fort) + tampon[0] = (longueur_totale & 0xF0) | 0x1 /* longueur supérieure à 7 bits */ | ((i + 1) << 1); for(j = 0; j <= i; j++) { - tampon[(i - j) + 1] = (longueur_totale >> (j + 1)) + tampon[(i - j) + 1] = + (longueur_totale >> (8 * (j + 1))) & 0xFF; } - // MSB (4 bits de poids faible) - tampon[i + 2] = (((longueur_totale >> 8) & 0x0F) << 4) + // LSB (4 bits de poids faible) + tampon[i + 2] = ((longueur_totale & 0x0F) << 4) | 0x1 /* longueur supérieure à 7 bits */ | ((i + 1) << 1); break; @@ -4093,7 +4289,7 @@ formateur_fichier_binaire_nombre(struct_ case 4: { if ((*((integer8 *) valeur_numerique)) != - ((integer2) (*((integer8 *) valeur_numerique)))) + ((integer4) (*((integer8 *) valeur_numerique)))) { (*s_etat_processus).erreur_execution = d_ex_representation; @@ -4525,6 +4721,8 @@ lecture_fichier_non_formate(struct_proce { file *fichier; + int j; + integer8 i; integer8 longueur; @@ -4535,6 +4733,7 @@ lecture_fichier_non_formate(struct_proce unsigned char octets[8]; unsigned char *buffer; + unsigned char *flux; unsigned char *ptr; size_t deplacement; @@ -4547,39 +4746,137 @@ lecture_fichier_non_formate(struct_proce } else { - buffer = argument; + buffer = (*((unsigned char **) argument)); ptr = buffer; fichier = NULL; } - if (longueur_buffer < 0) { if (fread(octets, (size_t) sizeof(unsigned char), 1, fichier) != 1) { - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + } + return(NULL); } } else { - octets[0] = *ptr++; + if ((longueur_buffer - (ptr - buffer)) >= 1) + { + octets[0] = *ptr++; + } + else + { + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + return(NULL); + } } switch(octets[0] & 0xF0) { - case 0x10: // Scalaire + case 0x00: // Binaire { - switch(octets[0] & 0x0C) + switch(octets[0] & 0x0F) { - case 0x00: // Entier + case 0x01: // logical*1 { - if ((s_objet = allocation(s_etat_processus, INT)) == NULL) + 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)) { - return(NULL); + (*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 * ((deplacement - 1) - i)); + } + + break; + } + + case 0x10: // Scalaire + { + switch(octets[0] & 0x0C) + { + case 0x00: // Entier + { switch(octets[0] & 0x03) { case 0x00: // integer*1 @@ -4612,25 +4909,49 @@ lecture_fichier_non_formate(struct_proce if (fread(octets, (size_t) sizeof(unsigned char), deplacement, fichier) != deplacement) { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = + d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + } + return(NULL); } } else { - for(i = 0; i < (signed) deplacement; i++) + if ((longueur_buffer - (ptr - buffer)) >= + (ssize_t) deplacement) { - octets[i] = *ptr++; + 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); + } + (*((integer8 *) (*s_objet).objet)) = 0; for(i = 0; i < (signed) deplacement; i++) { (*((integer8 *) (*s_objet).objet)) |= - octets[i] << (8 * ((deplacement - 1) - i)); + ((integer8) octets[i]) + << (8 * ((deplacement - 1) - i)); } break; @@ -4638,11 +4959,6 @@ lecture_fichier_non_formate(struct_proce case 0x04: // Réel { - if ((s_objet = allocation(s_etat_processus, REL)) == NULL) - { - return(NULL); - } - switch(octets[0] & 0x03) { case 0x00: // real*4 @@ -4670,19 +4986,43 @@ lecture_fichier_non_formate(struct_proce if (fread(octets, (size_t) sizeof(unsigned char), deplacement, fichier) != deplacement) { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = + d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + } + return(NULL); } } else { - for(i = 0; i < (signed) deplacement; i++) + if ((longueur_buffer - (ptr - buffer)) >= + (ssize_t) deplacement) { - octets[i] = *ptr++; + 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 @@ -4725,11 +5065,131 @@ lecture_fichier_non_formate(struct_proce 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 * ((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 * ((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; } @@ -4760,14 +5220,32 @@ lecture_fichier_non_formate(struct_proce if (fread(octets, (size_t) sizeof(unsigned char), 1, fichier) != 1) { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = + d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + } + return(NULL); } } else { - octets[0] = *ptr++; + if ((longueur_buffer - (ptr - buffer)) >= 1) + { + octets[0] = *ptr++; + } + else + { + (*s_etat_processus).erreur_execution = + d_ex_syntaxe; + return(NULL); + } } longueur = octets[0]; @@ -4781,15 +5259,32 @@ lecture_fichier_non_formate(struct_proce if (fread(octets, (size_t) sizeof(unsigned char), 2, fichier) != 2) { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = + d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + } + return(NULL); } } else { - octets[0] = *ptr++; - octets[1] = *ptr++; + 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) @@ -4804,17 +5299,32 @@ lecture_fichier_non_formate(struct_proce if (fread(octets, (size_t) sizeof(unsigned char), 4, fichier) != 4) { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = + d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + } + return(NULL); } } else { - octets[0] = *ptr++; - octets[1] = *ptr++; - octets[2] = *ptr++; - octets[3] = *ptr++; + 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) @@ -4831,21 +5341,32 @@ lecture_fichier_non_formate(struct_proce if (fread(octets, (size_t) sizeof(unsigned char), 8, fichier) != 8) { - (*s_etat_processus).erreur_systeme = - d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = + d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = + d_es_erreur_fichier; + } + return(NULL); } } else { - octets[0] = *ptr++; - octets[1] = *ptr++; - octets[2] = *ptr++; - octets[3] = *ptr++; - octets[4] = *ptr++; - octets[5] = *ptr++; - octets[6] = *ptr++; - octets[7] = *ptr++; + 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) @@ -4933,7 +5454,249 @@ lecture_fichier_non_formate(struct_proce case 0x80: // Chaîne de caractères { - s_objet = NULL; + 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(longueur * sizeof(unsigned char))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return(NULL); + } + + if (fread(flux, (size_t) sizeof(unsigned char), + 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; } @@ -4953,7 +5716,15 @@ lecture_fichier_non_formate(struct_proce { liberation(s_etat_processus, s_objet); - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + if (feof(fichier)) + { + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + } + else + { + (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + } + return(NULL); } @@ -4966,12 +5737,25 @@ lecture_fichier_non_formate(struct_proce { liberation(s_etat_processus, s_objet); - (*s_etat_processus).erreur_systeme = d_es_erreur_fichier; + 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); }