|
version 1.9, 2010/04/07 13:45:02
|
version 1.56, 2013/03/16 20:11:29
|
|
Line 1
|
Line 1
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| RPL/2 (R) version 4.0.14 |
RPL/2 (R) version 4.1.13 |
| Copyright (C) 1989-2010 Dr. BERTRAND Joël |
Copyright (C) 1989-2013 Dr. BERTRAND Joël |
| |
|
| This file is part of RPL/2. |
This file is part of RPL/2. |
| |
|
|
Line 19
|
Line 19
|
| ================================================================================ |
================================================================================ |
| */ |
*/ |
| |
|
| |
#define DEBUG_ERREURS |
| #include "rpl.conv.h" |
#include "rpl-conv.h" |
| |
|
| |
|
| /* |
/* |
|
Line 30
|
Line 30
|
| Entrées : structure sur l'état du processus et objet à afficher |
Entrées : structure sur l'état du processus et objet à afficher |
| Longueur est la précision requise et longueur_champ, le nombre maximal |
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) |
de caractères de la chaîne résultat (-1 signifiant une absence de contrainte) |
| Type = 'F/U' |
Type = 'F/U' (formaté, non formaté) |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Sorties : chaine de caractères et longueur du tableau de caractères |
Sorties : chaine de caractères et longueur du tableau de caractères |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
|
Line 42 unsigned char *
|
Line 42 unsigned char *
|
| formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet, |
formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet, |
| struct_objet *s_format, long longueur, long longueur_champ, |
struct_objet *s_format, long longueur, long longueur_champ, |
| unsigned char format_sortie, unsigned char type, |
unsigned char format_sortie, unsigned char type, |
| long *longueur_effective, long *recursivite) |
long *longueur_effective, long *recursivite, logical1 export_fichier) |
| { |
{ |
| /* |
/* |
| * Traitement du format des fichiers formatés : |
* Traitement du format des fichiers formatés : |
|
Line 62 formateur_fichier(struct_processus *s_et
|
Line 62 formateur_fichier(struct_processus *s_et
|
| * "binary*X(*)" |
* "binary*X(*)" |
| * "binary*X(Y)" (X est la base : 2, 8, 10, 16) |
* "binary*X(Y)" (X est la base : 2, 8, 10, 16) |
| * "character*(*)" |
* "character*(*)" |
| * "character*(Y)" } |
* "character*(Y)" |
| |
* "native*(*)" } |
| * |
* |
| * Traitement du format des fichiers non formatés : |
* Traitement du format des fichiers non formatés : |
| * |
* |
|
Line 70 formateur_fichier(struct_processus *s_et
|
Line 71 formateur_fichier(struct_processus *s_et
|
| * "real*4", "real*8", ["real*16",] |
* "real*4", "real*8", ["real*16",] |
| * "complex*8", "complex*16", ["complex*32",] |
* "complex*8", "complex*16", ["complex*32",] |
| * "logical*1", "logical*2", "logical*4", logical*8", |
* "logical*1", "logical*2", "logical*4", logical*8", |
| * "character" } |
* "character*n" "character*(*)" "native*(*)" } |
| */ |
*/ |
| |
|
| logical1 autorisation_parenthese; |
logical1 autorisation_parenthese; |
| logical1 format_degenere; |
logical1 format_degenere; |
| logical1 longueur_3bits; |
|
| logical1 longueur_6bits; |
|
| logical1 presence_signe; |
logical1 presence_signe; |
| |
|
| |
long longueur_chaine_traitee; |
| |
|
| struct_liste_chainee *l_atome; |
struct_liste_chainee *l_atome; |
| struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_courant; |
| struct_liste_chainee *l_element_courant_format; |
struct_liste_chainee *l_element_courant_format; |
|
Line 97 formateur_fichier(struct_processus *s_et
|
Line 98 formateur_fichier(struct_processus *s_et
|
| unsigned char *chaine_tampon; |
unsigned char *chaine_tampon; |
| unsigned char *chaine_sauvegarde; |
unsigned char *chaine_sauvegarde; |
| unsigned char *format_chaine; |
unsigned char *format_chaine; |
| unsigned char longueur_optimale; |
|
| unsigned char parametre_longueur; |
|
| unsigned char *ptre; |
unsigned char *ptre; |
| unsigned char *ptrl; |
unsigned char *ptrl; |
| unsigned char tampon[64 + 1]; |
unsigned char tampon[64 + 1]; |
| |
unsigned char type_binaire; |
| |
|
| unsigned long i; |
unsigned long i; |
| unsigned long j; |
unsigned long j; |
| unsigned long longueur_binaire; |
|
| unsigned long longueur_champ_final; |
|
| unsigned long nombre_arguments; |
unsigned long nombre_arguments; |
| unsigned long nombre_arguments_fonction; |
unsigned long nombre_arguments_fonction; |
| unsigned long nombre_colonnes; |
unsigned long nombre_colonnes; |
|
Line 114 formateur_fichier(struct_processus *s_et
|
Line 112 formateur_fichier(struct_processus *s_et
|
| unsigned long nombre_lignes; |
unsigned long nombre_lignes; |
| |
|
| integer8 longueur_liste; |
integer8 longueur_liste; |
| integer8 longueur_entete; |
integer8 longueur_reelle_chaine; |
| integer8 longueur_objet; |
|
| integer8 longueur_totale; |
integer8 longueur_totale; |
| integer8 masque_binaire; |
|
| integer8 position_1; |
integer8 position_1; |
| integer8 position_2; |
integer8 position_2; |
| integer8 position_3; |
integer8 position_3; |
| |
|
| long offset; |
|
| |
|
| (*recursivite)++; |
(*recursivite)++; |
| |
|
| if (type == 'F') |
if (type == 'F') |
|
Line 138 formateur_fichier(struct_processus *s_et
|
Line 132 formateur_fichier(struct_processus *s_et
|
| |
|
| strcpy(base, " "); |
strcpy(base, " "); |
| |
|
| longueur_binaire = 0; |
|
| masque_binaire = 0; |
|
| |
|
| if ((*s_objet).type == ALG) |
if ((*s_objet).type == ALG) |
| { |
{ |
| |
|
|
Line 150 formateur_fichier(struct_processus *s_et
|
Line 141 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; |
l_element_courant = (struct_liste_chainee *) (*s_objet).objet; |
| |
|
| while(l_element_courant != NULL) |
while(l_element_courant != NULL) |
|
Line 872 formateur_fichier(struct_processus *s_et
|
Line 870 formateur_fichier(struct_processus *s_et
|
| free(chaine_sauvegarde); |
free(chaine_sauvegarde); |
| |
|
| if ((s_sous_objet = allocation(s_etat_processus, |
if ((s_sous_objet = allocation(s_etat_processus, |
| CHN)) == NULL) |
CHN)) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_allocation_memoire; |
d_es_allocation_memoire; |
|
Line 903 formateur_fichier(struct_processus *s_et
|
Line 901 formateur_fichier(struct_processus *s_et
|
| if (((*s_sous_objet).objet = (void *) formateur_fichier( |
if (((*s_sous_objet).objet = (void *) formateur_fichier( |
| s_etat_processus, (*l_element_courant).donnee, |
s_etat_processus, (*l_element_courant).donnee, |
| s_format, longueur, longueur_champ, format_sortie, |
s_format, longueur, longueur_champ, format_sortie, |
| type, longueur_effective, recursivite)) == NULL) |
type, longueur_effective, recursivite, |
| |
export_fichier)) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_allocation_memoire; |
d_es_allocation_memoire; |
|
Line 991 formateur_fichier(struct_processus *s_et
|
Line 990 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if (format_sortie != 'B') |
if ((format_sortie != 'B') && (format_sortie != 'U')) |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| longueur_binaire = longueur_entiers_binaires(s_etat_processus); |
if (format_sortie == 'N') |
| 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)) |
|
| { |
{ |
| |
sprintf(tampon, "%llX", (*((logical8 *) |
| /* |
((*s_objet).objet)))); |
| -- Base décimale --------------------------------------------------------------- |
strcpy(base, "h"); |
| */ |
|
| |
|
| sprintf(tampon, "%llu", (*((logical8 *) |
|
| ((*s_objet).objet))) & masque_binaire); |
|
| strcpy(base, "d"); |
|
| } |
} |
| else if ((test_cfsf(s_etat_processus, 43) == d_vrai) && |
else |
| (test_cfsf(s_etat_processus, 44) == d_faux)) |
|
| { |
{ |
| |
switch(longueur) |
| |
{ |
| |
case 2: |
| |
{ |
| |
sprintf(tampon, "%llX", (*((logical8 *) |
| |
((*s_objet).objet)))); |
| |
|
| /* |
chaine = (unsigned char *) malloc((strlen(tampon) + 1) |
| -- Base octale ----------------------------------------------------------------- |
* sizeof(unsigned char)); |
| */ |
|
| |
|
| sprintf(tampon, "%llo", (*((logical8 *) |
if (chaine == NULL) |
| ((*s_objet).objet))) & masque_binaire); |
{ |
| strcpy(base, "o"); |
(*s_etat_processus).erreur_systeme = |
| } |
d_es_allocation_memoire; |
| else if (test_cfsf(s_etat_processus, 44) == d_vrai) |
return(NULL); |
| { |
} |
| |
|
| /* |
strcpy(chaine, tampon); |
| -- Bases hexadécimale et binaire ----------------------------------------------- |
tampon[0] = 0; |
| */ |
|
| |
|
| sprintf(tampon, "%llX", (*((logical8 *) |
for(i = 0; i < strlen(chaine); i++) |
| ((*s_objet).objet))) & masque_binaire); |
{ |
| |
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) |
free(chaine); |
| { |
strcpy(base, "b"); |
| strcpy(base, "h"); |
break; |
| } |
} |
| else |
|
| { |
|
| chaine = (unsigned char *) malloc((strlen(tampon) + 1) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
case 8: |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
sprintf(tampon, "%llo", (*((logical8 *) |
| d_es_allocation_memoire; |
((*s_objet).objet)))); |
| return(NULL); |
strcpy(base, "o"); |
| |
break; |
| } |
} |
| |
|
| strcpy(chaine, tampon); |
case 10: |
| tampon[0] = 0; |
{ |
| |
sprintf(tampon, "%llu", (*((logical8 *) |
| |
((*s_objet).objet)))); |
| |
strcpy(base, "d"); |
| |
break; |
| |
} |
| |
|
| for(i = 0; i < strlen(chaine); i++) |
case 16: |
| { |
{ |
| switch(chaine[i]) |
sprintf(tampon, "%llX", (*((logical8 *) |
| { |
((*s_objet).objet)))); |
| case '0' : |
strcpy(base, "h"); |
| { |
break; |
| 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); |
default: |
| strcpy(base, "b"); |
{ |
| |
(*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; |
| } |
} |
| } |
} |
| |
|
|
Line 1169 formateur_fichier(struct_processus *s_et
|
Line 1190 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if (format_sortie != 'C') |
if ((format_sortie != 'C') && (format_sortie != 'U')) |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if ((longueur_champ == -1) || (strlen((unsigned char *) |
longueur_reelle_chaine = longueur_chaine(s_etat_processus, |
| (*s_objet).objet) < longueur_champ)) |
(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 *) |
chaine = (unsigned char *) malloc((strlen((unsigned char *) |
| ((*s_objet).objet)) + 1) * sizeof(unsigned char)); |
((*s_objet).objet)) + 1) * sizeof(unsigned char)); |
|
Line 1193 formateur_fichier(struct_processus *s_et
|
Line 1222 formateur_fichier(struct_processus *s_et
|
| } |
} |
| else |
else |
| { |
{ |
| chaine = (unsigned char *) malloc((longueur_champ + 1) |
longueur_reelle_chaine = pointeur_ieme_caractere( |
| * sizeof(unsigned char)); |
s_etat_processus, (unsigned char *) |
| |
(*s_objet).objet, longueur_champ) |
| |
- ((unsigned char *) (*s_objet).objet); |
| |
|
| if (chaine == NULL) |
if ((chaine = malloc((longueur_reelle_chaine + 1) * |
| |
sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_allocation_memoire; |
d_es_allocation_memoire; |
|
Line 1204 formateur_fichier(struct_processus *s_et
|
Line 1236 formateur_fichier(struct_processus *s_et
|
| } |
} |
| |
|
| strncpy(chaine, (unsigned char *) ((*s_objet).objet), |
strncpy(chaine, (unsigned char *) ((*s_objet).objet), |
| longueur_champ); |
longueur_reelle_chaine); |
| chaine[longueur_champ] = d_code_fin_chaine; |
chaine[longueur_reelle_chaine] = d_code_fin_chaine; |
| } |
} |
| } |
} |
| else if ((*s_objet).type == CPL) |
else if ((*s_objet).type == CPL) |
|
Line 1217 formateur_fichier(struct_processus *s_et
|
Line 1249 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 1254 formateur_fichier(struct_processus *s_et
|
Line 1291 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); |
l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); |
| chaine_sauvegarde = chaine; |
chaine_sauvegarde = chaine; |
| |
|
|
Line 1262 formateur_fichier(struct_processus *s_et
|
Line 1306 formateur_fichier(struct_processus *s_et
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if ((chaine_formatee = formateur_fichier(s_etat_processus, |
| (*l_element_courant).donnee, s_format, |
(*l_element_courant).donnee, s_format, |
| longueur, longueur_champ, format_sortie, type, |
longueur, longueur_champ, format_sortie, type, |
| longueur_effective, recursivite)) == NULL) |
longueur_effective, recursivite, export_fichier)) |
| |
== NULL) |
| { |
{ |
| return(NULL); |
return(NULL); |
| } |
} |
|
Line 1335 formateur_fichier(struct_processus *s_et
|
Line 1380 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 1372 formateur_fichier(struct_processus *s_et
|
Line 1422 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 *) |
chaine = (unsigned char *) malloc((strlen((*((struct_fonction *) |
| ((*s_objet).objet))).nom_fonction) + 1) * |
((*s_objet).objet))).nom_fonction) + 1) * |
| sizeof(unsigned char)); |
sizeof(unsigned char)); |
|
Line 1419 formateur_fichier(struct_processus *s_et
|
Line 1476 formateur_fichier(struct_processus *s_et
|
| { |
{ |
| chaine_sauvegarde = chaine; |
chaine_sauvegarde = chaine; |
| |
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if (format_sortie != 'N') |
| (*l_element_courant).donnee, |
|
| (*l_element_courant_format).donnee, |
|
| 0, 0, ' ', 'F', longueur_effective, recursivite)) |
|
| == NULL) |
|
| { |
{ |
| 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) |
chaine = (unsigned char *) malloc((strlen(chaine_formatee) |
|
Line 1498 formateur_fichier(struct_processus *s_et
|
Line 1571 formateur_fichier(struct_processus *s_et
|
| position_1 = 10; |
position_1 = 10; |
| format_degenere = d_vrai; |
format_degenere = d_vrai; |
| } |
} |
| |
else if (strcmp("NATIVE*(*)", format_chaine) == 0) |
| |
{ |
| |
format_sortie = 'N'; |
| |
position_1 = 7; |
| |
format_degenere = d_vrai; |
| |
} |
| else |
else |
| { |
{ |
| free(chaine); |
free(chaine); |
|
Line 1508 formateur_fichier(struct_processus *s_et
|
Line 1587 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| position_3 = strlen(format_chaine); |
position_3 = strlen(format_chaine) - 1; |
| format_chaine[--position_3] = d_code_fin_chaine; |
|
| |
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; |
position_2 = position_1; |
| |
|
|
Line 1567 formateur_fichier(struct_processus *s_et
|
Line 1657 formateur_fichier(struct_processus *s_et
|
| } |
} |
| |
|
| if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > |
if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > |
| longueur_champ)) |
longueur_champ) && (format_sortie != 'B')) |
| { |
{ |
| free(chaine); |
free(chaine); |
| free(format_chaine); |
free(format_chaine); |
|
Line 1584 formateur_fichier(struct_processus *s_et
|
Line 1674 formateur_fichier(struct_processus *s_et
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if ((chaine_formatee = formateur_fichier(s_etat_processus, |
| (*l_element_courant).donnee, s_format, |
(*l_element_courant).donnee, s_format, |
| longueur, longueur_champ, format_sortie, type, |
longueur, longueur_champ, format_sortie, type, |
| longueur_effective, recursivite)) == NULL) |
longueur_effective, recursivite, export_fichier)) |
| |
== NULL) |
| { |
{ |
| free(chaine); |
free(chaine); |
| return(NULL); |
return(NULL); |
|
Line 1653 formateur_fichier(struct_processus *s_et
|
Line 1744 formateur_fichier(struct_processus *s_et
|
| |
|
| nombre_elements++; |
nombre_elements++; |
| l_element_courant = (*l_element_courant).suivant; |
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) || |
// Dans le cas où le format de sortie n'est pas du type |
| (l_element_courant_format != NULL)) |
// 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 = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| |
} |
| } |
} |
| |
|
| chaine_sauvegarde = chaine; |
chaine_sauvegarde = chaine; |
|
Line 1689 formateur_fichier(struct_processus *s_et
|
Line 1792 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((*s_format).type != TBL) |
if (((*s_format).type != TBL) && (format_sortie != 'N')) |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| l_element_courant = (struct_liste_chainee *) (*s_objet).objet; |
if (format_sortie != 'N') |
| l_element_courant_format = (struct_liste_chainee *) |
|
| (*s_format).objet; |
|
| |
|
| if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != |
|
| (*((struct_tableau *) (*s_format).objet)).nombre_elements) |
|
| { |
{ |
| (*s_etat_processus).erreur_execution = |
if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != |
| d_ex_erreur_format_fichier; |
(*((struct_tableau *) (*s_format).objet)) |
| return(NULL); |
.nombre_elements) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| } |
} |
| |
|
| chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); |
chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); |
|
Line 1721 formateur_fichier(struct_processus *s_et
|
Line 1824 formateur_fichier(struct_processus *s_et
|
| for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) |
for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) |
| .nombre_elements; i++) |
.nombre_elements; i++) |
| { |
{ |
| if ((((*(*((struct_tableau *) (*s_format).objet)) |
if (format_sortie != 'N') |
| .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 == TAB))) |
|
| { |
{ |
| chaine_sauvegarde = chaine; |
if ((((*(*((struct_tableau *) (*s_format).objet)) |
| |
.elements[i]).type == LST) && |
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
((*(*((struct_tableau *) (*s_objet).objet)) |
| (*l_element_courant).donnee, |
.elements[i]).type == LST)) || |
| (*l_element_courant_format).donnee, |
(((*(*((struct_tableau *) (*s_format).objet)) |
| 0, 0, ' ', 'F', longueur_effective, recursivite)) |
.elements[i]).type == TBL) && |
| == NULL) |
((*(*((struct_tableau *) (*s_objet).objet)) |
| |
.elements[i]).type == TBL))) |
| { |
{ |
| return(NULL); |
chaine_sauvegarde = chaine; |
| } |
|
| |
|
| chaine = (unsigned char *) malloc((strlen(chaine_formatee) |
|
| + strlen(chaine_sauvegarde) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| else if ((*(*((struct_tableau *) (*s_format).objet)) |
|
| .elements[i]).type != CHN) |
|
| { |
|
| free(chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
if ((chaine_formatee = formateur_fichier( |
| d_ex_erreur_format_fichier; |
s_etat_processus, |
| return(NULL); |
(*(*((struct_tableau *) (*s_objet).objet)) |
| } |
.elements[i]).objet, |
| else |
(*(*((struct_tableau *) (*s_format).objet)) |
| { |
.elements[i]).objet, |
| if ((format_chaine = conversion_majuscule((unsigned char *) |
0, 0, ' ', 'F', longueur_effective, recursivite, |
| (*(*((struct_tableau *) (*s_format).objet)) |
export_fichier)) == NULL) |
| .elements[i]).objet)) == NULL) |
{ |
| { |
return(NULL); |
| (*s_etat_processus).erreur_systeme = |
} |
| d_es_allocation_memoire; |
|
| 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) |
strcpy(chaine, chaine_sauvegarde); |
| { |
free(chaine_sauvegarde); |
| format_sortie = 'S'; |
strcat(chaine, " "); |
| position_1 = 9; |
strcat(chaine, chaine_formatee); |
| format_degenere = d_vrai; |
free(chaine_formatee); |
| } |
|
| 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 |
else if ((*(*((struct_tableau *) (*s_format).objet)) |
| |
.elements[i]).type != CHN) |
| { |
{ |
| free(chaine); |
free(chaine); |
| free(format_chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
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_degenere = d_faux; |
| format_chaine[--position_3] = d_code_fin_chaine; |
|
| |
|
| position_2 = position_1; |
|
| |
|
| while(format_chaine[position_2] != '(') |
if (strncmp("STANDARD*", format_chaine, 9) == 0) |
| { |
{ |
| if (format_chaine[position_2] == d_code_fin_chaine) |
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(chaine); |
| free(format_chaine); |
free(format_chaine); |
|
Line 1839 formateur_fichier(struct_processus *s_et
|
Line 1935 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
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) |
while(format_chaine[position_2] != '(') |
| { |
|
| if (sscanf(&(format_chaine[position_1]), "%ld", |
|
| &longueur) != 1) |
|
| { |
{ |
| free(chaine); |
if (format_chaine[position_2] == d_code_fin_chaine) |
| free(format_chaine); |
{ |
| |
free(chaine); |
| |
free(format_chaine); |
| |
|
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| |
} |
| |
|
| |
position_2++; |
| } |
} |
| } |
|
| else |
|
| { |
|
| longueur = -1; |
|
| } |
|
| |
|
| if (strcmp(&(format_chaine[position_2]), "*") != 0) |
format_chaine[position_2++] = d_code_fin_chaine; |
| { |
|
| if (sscanf(&(format_chaine[position_2]), "%ld", |
if (format_degenere == d_faux) |
| &longueur_champ) != 1) |
{ |
| |
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(chaine); |
| free(format_chaine); |
free(format_chaine); |
|
Line 1874 formateur_fichier(struct_processus *s_et
|
Line 2003 formateur_fichier(struct_processus *s_et
|
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| } |
|
| else |
|
| { |
|
| longueur_champ = -1; |
|
| } |
|
| |
|
| if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > |
|
| longueur_champ)) |
|
| { |
|
| free(chaine); |
|
| free(format_chaine); |
free(format_chaine); |
| |
|
| |
chaine_sauvegarde = chaine; |
| |
|
| (*s_etat_processus).erreur_execution = |
if ((chaine_formatee = formateur_fichier( |
| d_ex_erreur_format_fichier; |
s_etat_processus, (*((struct_tableau *) |
| return(NULL); |
(*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; |
chaine_sauvegarde = chaine; |
| |
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if ((chaine_formatee = formateur_fichier( |
| (*((struct_tableau *) (*s_objet).objet)) |
s_etat_processus, (*((struct_tableau *) |
| .elements[i], s_format, |
(*s_objet).objet)).elements[i], s_format, |
| longueur, longueur_champ, format_sortie, type, |
longueur, longueur_champ, format_sortie, type, |
| longueur_effective, recursivite)) == NULL) |
longueur_effective, recursivite, |
| |
export_fichier)) == NULL) |
| { |
{ |
| return(NULL); |
return(NULL); |
| } |
} |
| |
} |
| |
|
| if ((*(*((struct_tableau *) (*s_objet).objet)) |
if ((*(*((struct_tableau *) (*s_objet).objet)) |
| .elements[i]).type == CHN) |
.elements[i]).type == CHN) |
| { |
{ |
| chaine = (unsigned char *) |
chaine = (unsigned char *) |
| malloc((strlen(chaine_formatee) |
malloc((strlen(chaine_formatee) |
| + strlen(chaine_sauvegarde) + 4) |
+ strlen(chaine_sauvegarde) + 4) |
| * sizeof(unsigned char)); |
* sizeof(unsigned char)); |
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
if (chaine == NULL) |
| 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 *) |
(*s_etat_processus).erreur_systeme = |
| malloc((strlen(chaine_formatee) |
d_es_allocation_memoire; |
| + strlen(chaine_sauvegarde) + 2) |
return(NULL); |
| * sizeof(unsigned char)); |
} |
| |
|
| if (chaine == NULL) |
strcpy(chaine, chaine_sauvegarde); |
| { |
free(chaine_sauvegarde); |
| (*s_etat_processus).erreur_systeme = |
strcat(chaine, " \""); |
| d_es_allocation_memoire; |
strcat(chaine, chaine_formatee); |
| return(NULL); |
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, |
if (chaine == NULL) |
| chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| else |
|
| { |
{ |
| chaine = (unsigned char *) |
(*s_etat_processus).erreur_systeme = |
| malloc((strlen(chaine_formatee) |
d_es_allocation_memoire; |
| + strlen(chaine_sauvegarde) + 2) |
return(NULL); |
| * sizeof(unsigned char)); |
} |
| |
|
| if (chaine == NULL) |
sprintf(chaine, "%s %s", chaine_sauvegarde, |
| { |
chaine_formatee); |
| (*s_etat_processus).erreur_systeme = |
free(chaine_formatee); |
| d_es_allocation_memoire; |
} |
| return(NULL); |
else |
| } |
{ |
| |
chaine = (unsigned char *) |
| |
malloc((strlen(chaine_formatee) |
| |
+ strlen(chaine_sauvegarde) + 2) |
| |
* sizeof(unsigned char)); |
| |
|
| strcpy(chaine, chaine_sauvegarde); |
if (chaine == NULL) |
| free(chaine_sauvegarde); |
{ |
| strcat(chaine, " "); |
(*s_etat_processus).erreur_systeme = |
| strcat(chaine, chaine_formatee); |
d_es_allocation_memoire; |
| free(chaine_formatee); |
return(NULL); |
| } |
} |
| |
|
| |
strcpy(chaine, chaine_sauvegarde); |
| |
free(chaine_sauvegarde); |
| |
strcat(chaine, " "); |
| |
strcat(chaine, chaine_formatee); |
| |
free(chaine_formatee); |
| } |
} |
| } |
} |
| |
|
|
Line 1991 formateur_fichier(struct_processus *s_et
|
Line 2120 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 2134 formateur_fichier(struct_processus *s_et
|
Line 2268 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 2276 formateur_fichier(struct_processus *s_et
|
Line 2415 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 2418 formateur_fichier(struct_processus *s_et
|
Line 2562 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 *) |
chaine = (unsigned char *) malloc((strlen((*((struct_nom *) |
| (*s_objet).objet)).nom) + 3) * sizeof(unsigned char)); |
(*s_objet).objet)).nom) + 3) * sizeof(unsigned char)); |
| |
|
|
Line 2438 formateur_fichier(struct_processus *s_et
|
Line 2589 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 2475 formateur_fichier(struct_processus *s_et
|
Line 2631 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 2551 formateur_fichier(struct_processus *s_et
|
Line 2712 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 2626 formateur_fichier(struct_processus *s_et
|
Line 2792 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
} |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'S') && (format_sortie != 'F') && |
| (format_sortie != 'I') && (format_sortie != 'E')) |
(format_sortie != 'I') && (format_sortie != 'E')) |
| { |
{ |
|
Line 2711 formateur_fichier(struct_processus *s_et
|
Line 2882 formateur_fichier(struct_processus *s_et
|
| */ |
*/ |
| |
|
| #define __zone() \ |
#define __zone() \ |
| do { int _i; for(_i = 0; _i < longueur_totale; _i++) \ |
do { int _i; \ |
| printf("%02X ", chaine[_i]); printf("\b\n"); } while(0) |
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) |
* Chaque enregistrement est composé d'une donnée (une liste) |
|
Line 2729 formateur_fichier(struct_processus *s_et
|
Line 2901 formateur_fichier(struct_processus *s_et
|
| * |
* |
| * Longueur : (pour l'instruction backspace) |
* Longueur : (pour l'instruction backspace) |
| * |
* |
| * 00 XXXXXX longueur sur 6 bits |
* XXXXXXX0 longueur sur 7 bits |
| * 01 ------ longueur sur 16 bits |
* XXXX0011 XXXXXXXX XXXX0011 longueur sur 16 bits |
| * 10 ------ longueur sur 32 bits |
* LSB(1/2) MSB LSB(2/2) |
| * 11 ------ longueur sur 64 bits |
* 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 : |
* Structures des enregistrements : |
| * chaque type de donnée est associé à une en-tête binaire comprenant |
* chaque type de donnée est associé à une en-tête binaire comprenant |
|
Line 2813 formateur_fichier(struct_processus *s_et
|
Line 2997 formateur_fichier(struct_processus *s_et
|
| * 1001 10 10 table de longueur integer*4 |
* 1001 10 10 table de longueur integer*4 |
| * 1001 10 11 table de longueur integer*8 |
* 1001 10 11 table de longueur integer*8 |
| * |
* |
| |
* 1010 00 10 vecteur real*4 (dimensions integer*1) |
| |
* 1010 01 10 vecteur real*4 (dimensions integer*2) |
| |
* 1010 10 10 vecteur real*4 (dimensions integer*4) |
| |
* 1010 11 10 vecteur real*4 (dimensions integer*8) |
| |
* 1010 00 11 vecteur real*8 (dimensions integer*1) |
| |
* 1010 01 11 vecteur real*8 (dimensions integer*2) |
| |
* 1010 10 11 vecteur real*8 (dimensions integer*4) |
| |
* 1010 11 11 vecteur real*8 (dimensions integer*8) |
| |
* 1011 00 10 vecteur complex*8 (dimensions integer*1) |
| |
* 1011 01 10 vecteur complex*8 (dimensions integer*2) |
| |
* 1011 10 10 vecteur complex*8 (dimensions integer*4) |
| |
* 1011 11 10 vecteur complex*8 (dimensions integer*8) |
| |
* 1011 00 11 vecteur complex*16 (dimensions integer*1) |
| |
* 1011 01 11 vecteur complex*16 (dimensions integer*2) |
| |
* 1011 10 11 vecteur complex*16 (dimensions integer*4) |
| |
* 1011 11 11 vecteur complex*16 (dimensions integer*8) |
| |
* |
| |
* 1100 00 10 matrice real*4 (dimensions integer*1) |
| |
* 1100 01 10 matrice real*4 (dimensions integer*2) |
| |
* 1100 10 10 matrice real*4 (dimensions integer*4) |
| |
* 1100 11 10 matrice real*4 (dimensions integer*8) |
| |
* 1100 00 11 matrice real*8 (dimensions integer*1) |
| |
* 1100 01 11 matrice real*8 (dimensions integer*2) |
| |
* 1100 10 11 matrice real*8 (dimensions integer*4) |
| |
* 1100 11 11 matrice real*8 (dimensions integer*8) |
| |
* 1101 00 10 matrice complex*8 (dimensions integer*1) |
| |
* 1101 01 10 matrice complex*8 (dimensions integer*2) |
| |
* 1101 10 10 matrice complex*8 (dimensions integer*4) |
| |
* 1101 11 10 matrice complex*8 (dimensions integer*8) |
| |
* 1101 00 11 matrice complex*16 (dimensions integer*1) |
| |
* 1101 01 11 matrice complex*16 (dimensions integer*2) |
| |
* 1101 10 11 matrice complex*16 (dimensions integer*4) |
| |
* 1101 11 11 matrice complex*16 (dimensions integer*8) |
| |
* |
| * Les longueurs indiquées par le champ LL suivent l'en-tête : |
* 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] |
* [En-tête][longueur_1][longueur_2][données] |
| * le nombre de champs longueur dépendant des types d'enregistrement. |
* le nombre de champs longueur dépendant des types d'enregistrement. |
| * |
* |
|
Line 2824 formateur_fichier(struct_processus *s_et
|
Line 3047 formateur_fichier(struct_processus *s_et
|
| chaine_formatee = NULL; |
chaine_formatee = NULL; |
| chaine_sauvegarde = NULL; |
chaine_sauvegarde = NULL; |
| |
|
| strcpy(base, " "); |
if ((*s_objet).type == BIN) |
| |
|
| longueur_binaire = 0; |
|
| masque_binaire = 0; |
|
| |
|
| if ((*s_objet).type == ALG) |
|
| { |
{ |
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Expression algébrique |
Entier binaire en base 2, 8, 10 ou 16 |
| |
Poids fort 0000 |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| l_element_courant = (struct_liste_chainee *) (*s_objet).objet; |
if (format_sortie != 'L') |
| |
|
| while(l_element_courant != NULL) |
|
| { |
{ |
| if ((*(*l_element_courant).donnee).type == FCT) |
(*s_etat_processus).erreur_execution = |
| { |
d_ex_erreur_format_fichier; |
| if ((strcmp((*((struct_fonction *) (*(*l_element_courant) |
return(NULL); |
| .donnee).objet)).nom_fonction, "<<") != 0) && |
} |
| (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant) |
|
| .donnee).objet)).nom_fonction, ">>") != 0)) |
|
| { |
|
| if ((strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant) |
|
| .donnee).objet)).nom_fonction, "+") == 0) || |
|
| (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "-") == 0) || (strcmp( |
|
| (*((struct_fonction *) (*(*l_element_courant) |
|
| .donnee).objet)).nom_fonction, "*") == 0) || |
|
| (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "/") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "^") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "<") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| ">") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "==") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "<>") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "<=") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "=<") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| ">=") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "=>") == 0)) |
|
| { |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), &s_sous_objet_2) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine_sauvegarde = (*s_etat_processus) |
|
| .instruction_courante; |
|
| |
|
| if (((*s_etat_processus).instruction_courante = |
|
| (unsigned char *) malloc((strlen( |
|
| (unsigned char *) (*s_sous_objet_2).objet) |
|
| + 2 + 1) * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).instruction_courante = |
|
| chaine_sauvegarde; |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((*s_etat_processus).instruction_courante, |
|
| "'%s'", (unsigned char *) |
|
| (*s_sous_objet_2).objet); |
|
| |
|
| presence_signe = (((*s_etat_processus) |
|
| .instruction_courante[1] == '+') |
|
| || ((*s_etat_processus) |
|
| .instruction_courante[1] |
|
| == '-')) ? d_vrai : d_faux; |
|
| |
|
| recherche_type(s_etat_processus); |
|
| |
|
| if ((*s_etat_processus).erreur_execution != d_ex) |
|
| { |
|
| // Aucune erreur ne peut être renvoyée. |
|
| |
|
| return(NULL); |
|
| } |
|
| |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), &s_sous_objet_3) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| free((*s_etat_processus).instruction_courante); |
|
| |
|
| (*s_etat_processus).instruction_courante = |
|
| chaine_sauvegarde; |
|
| |
|
| autorisation_parenthese = d_faux; |
|
| |
|
| if ((*s_sous_objet_3).type == ALG) |
|
| { |
|
| l_atome = (struct_liste_chainee *) |
|
| (*s_sous_objet_3).objet; |
|
| chaine_fonction = ""; |
|
| nombre_arguments_fonction = 0; |
|
| |
|
| while(l_atome != NULL) |
|
| { |
|
| if ((*(*l_atome).donnee).type == FCT) |
|
| { |
|
| if (strcmp((*((struct_fonction *) |
|
| (*(*l_atome).donnee).objet)) |
|
| .nom_fonction, ">>") != 0) |
|
| { |
|
| chaine_fonction = |
|
| (*((struct_fonction *) |
|
| (*(*l_atome).donnee).objet)) |
|
| .nom_fonction; |
|
| nombre_arguments_fonction = |
|
| (*((struct_fonction *) |
|
| (*(*l_atome).donnee).objet)) |
|
| .nombre_arguments; |
|
| } |
|
| } |
|
| |
|
| l_atome = (*l_atome).suivant; |
|
| } |
|
| |
|
| if (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "+") == 0) |
|
| { |
|
| if ((strcmp(chaine_fonction, "AND") == 0) || |
|
| (strcmp(chaine_fonction, "XOR") == |
|
| 0) || (strcmp(chaine_fonction, "OR") |
|
| == 0)) |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| else if (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "-") == 0) |
|
| { |
|
| if (nombre_arguments_fonction != 0) |
|
| { |
|
| autorisation_parenthese = d_faux; |
|
| } |
|
| else |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| else if (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "*") == 0) |
|
| { |
|
| if ((strcmp(chaine_fonction, "+") == 0) || |
|
| (strcmp(chaine_fonction, "-") == 0) |
|
| || (strcmp(chaine_fonction, "AND") |
|
| == 0) || (strcmp(chaine_fonction, |
|
| "XOR") == 0) || (strcmp( |
|
| chaine_fonction, "OR") == 0)) |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| else if (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "/") == 0) |
|
| { |
|
| if (nombre_arguments_fonction != 0) |
|
| { |
|
| autorisation_parenthese = d_faux; |
|
| } |
|
| else |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| else if ((strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "^") == 0)) |
|
| { |
|
| if (nombre_arguments_fonction != 0) |
|
| { |
|
| autorisation_parenthese = d_faux; |
|
| } |
|
| else |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| } |
|
| |
|
| if ((autorisation_parenthese == d_vrai) || |
|
| (presence_signe == d_vrai)) |
|
| { |
|
| chaine_sauvegarde = (unsigned char *) |
|
| (*s_sous_objet_2).objet; |
|
| |
|
| if (((*s_sous_objet_2).objet = (void *) |
|
| malloc((strlen(chaine_sauvegarde) + 2 |
|
| + 1) * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet_2) |
|
| .objet, "(%s)", chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| } |
|
| |
|
| liberation(s_etat_processus, s_sous_objet_3); |
|
| |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), &s_sous_objet_1) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine_sauvegarde = (*s_etat_processus) |
|
| .instruction_courante; |
|
| |
|
| if (((*s_etat_processus).instruction_courante = |
|
| (unsigned char *) malloc((strlen( |
|
| (unsigned char *) (*s_sous_objet_1).objet) |
|
| + 2 + 1) * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).instruction_courante = |
|
| chaine_sauvegarde; |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((*s_etat_processus).instruction_courante, |
|
| "'%s'", (unsigned char *) |
|
| (*s_sous_objet_1).objet); |
|
| |
|
| recherche_type(s_etat_processus); |
|
| |
|
| if ((*s_etat_processus).erreur_execution != d_ex) |
|
| { |
|
| // Aucune erreur ne peut être renvoyée. |
|
| |
|
| return(NULL); |
|
| } |
|
| |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), &s_sous_objet_3) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| free((*s_etat_processus).instruction_courante); |
|
| |
|
| (*s_etat_processus).instruction_courante = |
|
| chaine_sauvegarde; |
|
| |
|
| autorisation_parenthese = d_faux; |
|
| |
|
| if ((*s_sous_objet_3).type == ALG) |
|
| { |
|
| l_atome = (struct_liste_chainee *) |
|
| (*s_sous_objet_3).objet; |
|
| chaine_fonction = ""; |
|
| |
|
| while(l_atome != NULL) |
|
| { |
|
| if ((*(*l_atome).donnee).type == FCT) |
|
| { |
|
| if (strcmp((*((struct_fonction *) |
|
| (*(*l_atome).donnee).objet)) |
|
| .nom_fonction, ">>") != 0) |
|
| { |
|
| chaine_fonction = |
|
| (*((struct_fonction *) |
|
| (*(*l_atome).donnee).objet)) |
|
| .nom_fonction; |
|
| } |
|
| } |
|
| |
|
| l_atome = (*l_atome).suivant; |
|
| } |
|
| |
|
| if ((strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "+") == 0) || |
|
| (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "-") == 0)) |
|
| { |
|
| if ((strcmp(chaine_fonction, "AND") == 0) || |
|
| (strcmp(chaine_fonction, "XOR") == |
|
| 0) || (strcmp(chaine_fonction, "OR") |
|
| == 0)) |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| else if ((strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "*") == 0) || |
|
| (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "/") == 0)) |
|
| { |
|
| if ((strcmp(chaine_fonction, "+") == 0) || |
|
| (strcmp(chaine_fonction, "-") == 0) |
|
| || (strcmp(chaine_fonction, "AND") |
|
| == 0) || (strcmp(chaine_fonction, |
|
| "XOR") == 0) || (strcmp( |
|
| chaine_fonction, "OR") == 0)) |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| else if ((strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "^") == 0)) |
|
| { |
|
| autorisation_parenthese = d_vrai; |
|
| } |
|
| } |
|
| |
|
| if (autorisation_parenthese == d_vrai) |
|
| { |
|
| chaine_sauvegarde = (unsigned char *) |
|
| (*s_sous_objet_1).objet; |
|
| |
|
| if (((*s_sous_objet_1).objet = (void *) |
|
| malloc((strlen(chaine_sauvegarde) + 2 |
|
| + 1) * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet_1) |
|
| .objet, "(%s)", chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| } |
|
| |
|
| liberation(s_etat_processus, s_sous_objet_3); |
|
| |
|
| if ((s_sous_objet = allocation(s_etat_processus, |
|
| CHN)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| if (((*s_sous_objet).objet = (void *) |
|
| malloc((strlen( |
|
| (unsigned char *) (*s_sous_objet_1).objet) + |
|
| strlen((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction) + strlen((unsigned char *) |
|
| (*s_sous_objet_2).objet) + 1) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet).objet, |
|
| "%s%s%s", (unsigned char *) |
|
| (*s_sous_objet_1) |
|
| .objet, (*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, (unsigned char *) |
|
| (*s_sous_objet_2).objet); |
|
| |
|
| liberation(s_etat_processus, s_sous_objet_1); |
|
| liberation(s_etat_processus, s_sous_objet_2); |
|
| |
|
| if (empilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), s_sous_objet) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| } |
|
| else if (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, "=") == 0) |
|
| { |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus).l_base_pile), |
|
| &s_sous_objet_2) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus).l_base_pile), |
|
| &s_sous_objet_1) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if ((s_sous_objet = allocation(s_etat_processus, |
|
| CHN)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| autorisation_parenthese = d_vrai; |
|
| l_atome = l_element_courant; |
|
| |
|
| if (l_atome != NULL) |
|
| { |
|
| if ((*l_atome).suivant != NULL) |
|
| { |
|
| l_atome = (*l_atome).suivant; |
|
| |
|
| if ((*(*l_atome).donnee).type == FCT) |
|
| { |
|
| if (strcmp((*((struct_fonction *) |
|
| (*(*l_atome).donnee).objet)) |
|
| .nom_fonction, ">>") == 0) |
|
| { |
|
| if ((*l_atome).suivant == NULL) |
|
| { |
|
| autorisation_parenthese = |
|
| d_faux; |
|
| } |
|
| } |
|
| } |
|
| } |
|
| } |
|
| |
|
| if (autorisation_parenthese == d_vrai) |
|
| { |
|
| if (((*s_sous_objet).objet = |
|
| (void *) malloc((strlen( |
|
| (unsigned char *) (*s_sous_objet_1) |
|
| .objet) + strlen((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction) + |
|
| strlen((unsigned char *) |
|
| (*s_sous_objet_2).objet) + 2 + 1) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet).objet, |
|
| "(%s%s%s)", (unsigned char *) |
|
| (*s_sous_objet_1) |
|
| .objet, (*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, (unsigned char *) |
|
| (*s_sous_objet_2).objet); |
|
| } |
|
| else |
|
| { |
|
| if (((*s_sous_objet).objet = |
|
| (void *) malloc((strlen( |
|
| (unsigned char *) (*s_sous_objet_1) |
|
| .objet) + strlen((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction) + strlen( |
|
| (unsigned char *) (*s_sous_objet_2) |
|
| .objet) + 1) * sizeof(unsigned char))) |
|
| == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet).objet, |
|
| "%s%s%s", (unsigned char *) |
|
| (*s_sous_objet_1) |
|
| .objet, (*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, (unsigned char *) |
|
| (*s_sous_objet_2).objet); |
|
| } |
|
| |
|
| liberation(s_etat_processus, s_sous_objet_1); |
|
| liberation(s_etat_processus, s_sous_objet_2); |
|
| |
|
| if (empilement(s_etat_processus, |
|
| &((*s_etat_processus).l_base_pile), |
|
| s_sous_objet) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| } |
|
| else if (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "NOT") == 0) |
|
| { |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), &s_sous_objet_1) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if ((s_sous_objet = allocation(s_etat_processus, |
|
| CHN)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| if (((*s_sous_objet).objet = (unsigned char *) |
|
| malloc( |
|
| (strlen((unsigned char *) (*s_sous_objet_1) |
|
| .objet) + 4 + 1) * sizeof(unsigned char))) |
|
| == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet).objet, |
|
| "%s %s", (*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, (unsigned char *) |
|
| (*s_sous_objet_1).objet ); |
|
| |
|
| liberation(s_etat_processus, s_sous_objet_1); |
|
| |
|
| if (empilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), s_sous_objet) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| } |
|
| else if ((strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "OR") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "XOR") == 0) || (strcmp((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, |
|
| "AND") == 0)) |
|
| { |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), &s_sous_objet_2) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), &s_sous_objet_1) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if ((s_sous_objet = allocation(s_etat_processus, |
|
| CHN)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| if (((*s_sous_objet).objet = (void *) |
|
| malloc((strlen( |
|
| (unsigned char *) (*s_sous_objet_1).objet) + |
|
| strlen((*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction) + strlen((unsigned char *) |
|
| (*s_sous_objet_2).objet) + 2 + 1) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet).objet, |
|
| "%s %s %s", (unsigned char *) |
|
| (*s_sous_objet_1) |
|
| .objet, (*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, (unsigned char *) |
|
| (*s_sous_objet_2).objet); |
|
| |
|
| liberation(s_etat_processus, s_sous_objet_1); |
|
| liberation(s_etat_processus, s_sous_objet_2); |
|
| |
|
| if (empilement(s_etat_processus, |
|
| &((*s_etat_processus) |
|
| .l_base_pile), s_sous_objet) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| } |
|
| else |
|
| { |
|
| nombre_arguments = (*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nombre_arguments; |
|
| |
|
| if ((chaine = (unsigned char *) |
|
| malloc(sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine[0] = d_code_fin_chaine; |
|
| |
|
| for(i = 0; i < nombre_arguments; i++) |
|
| { |
|
| if ((nombre_arguments - i) > 1) |
|
| { |
|
| l_liste1 = (*s_etat_processus).l_base_pile; |
|
| |
|
| for(j = 2; j < (nombre_arguments - i); j++) |
|
| { |
|
| l_liste1 = (*l_liste1).suivant; |
|
| } |
|
| |
|
| l_liste2 = (*l_liste1).suivant; |
|
| (*l_liste1).suivant = (*l_liste2).suivant; |
|
| (*l_liste2).suivant = (*s_etat_processus) |
|
| .l_base_pile; |
|
| (*s_etat_processus).l_base_pile = l_liste2; |
|
| } |
|
| |
|
| if (depilement(s_etat_processus, |
|
| &((*s_etat_processus).l_base_pile), |
|
| &s_sous_objet) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| |
|
| if (strlen(chaine_sauvegarde) == 0) |
|
| { |
|
| if ((chaine = (unsigned char *) |
|
| malloc((strlen((unsigned char *) |
|
| (*s_sous_objet).objet) + 1) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf(chaine, "%s", (unsigned char *) |
|
| (*s_sous_objet).objet); |
|
| } |
|
| else |
|
| { |
|
| if ((chaine = (unsigned char *) |
|
| malloc((strlen(chaine_sauvegarde) |
|
| + 1 + strlen((unsigned char *) |
|
| (*s_sous_objet).objet) + 1) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf(chaine, "%s,%s", chaine_sauvegarde, |
|
| (unsigned char *) (*s_sous_objet) |
|
| .objet); |
|
| } |
|
| |
|
| free(chaine_sauvegarde); |
|
| liberation(s_etat_processus, s_sous_objet); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| |
|
| if ((chaine = (unsigned char *) malloc((strlen( |
|
| (*((struct_fonction *) |
|
| (*(*l_element_courant) |
|
| .donnee).objet)).nom_fonction) + 2 + |
|
| strlen(chaine_sauvegarde) + 1) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf(chaine, "%s(%s)", (*((struct_fonction *) |
|
| (*(*l_element_courant).donnee).objet)) |
|
| .nom_fonction, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| |
|
| if ((s_sous_objet = allocation(s_etat_processus, |
|
| CHN)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| (*s_sous_objet).objet = (void *) chaine; |
|
| |
|
| if (empilement(s_etat_processus, |
if (longueur_champ < 8) |
| &((*s_etat_processus) |
{ |
| .l_base_pile), s_sous_objet) == d_erreur) |
if ((*((logical8 *) (*s_objet).objet)) >= |
| { |
((logical8) 1 << (8 * longueur_champ))) |
| return(NULL); |
|
| } |
|
| } |
|
| } |
|
| } |
|
| else |
|
| { |
{ |
| if ((s_sous_objet = allocation(s_etat_processus, CHN)) |
(*s_etat_processus).erreur_execution = |
| == NULL) |
d_ex_representation; |
| { |
return(NULL); |
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| if (((*s_sous_objet).objet = (void *) formateur_fichier( |
|
| s_etat_processus, (*l_element_courant).donnee, |
|
| s_format, longueur, longueur_champ, format_sortie, |
|
| type, longueur_effective, recursivite)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| if (((*(*l_element_courant).donnee).type == ALG) |
|
| || ((*(*l_element_courant).donnee).type == NOM)) |
|
| { |
|
| chaine_sauvegarde = (unsigned char *) |
|
| (*s_sous_objet).objet; |
|
| |
|
| if (((*s_sous_objet).objet = malloc((strlen( |
|
| chaine_sauvegarde) - 1) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| ptrl = chaine_sauvegarde; |
|
| ptre = (unsigned char *) (*s_sous_objet).objet; |
|
| |
|
| for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0; |
|
| i--, *ptre++ = *ptrl++); |
|
| |
|
| (*ptre) = d_code_fin_chaine; |
|
| |
|
| free(chaine_sauvegarde); |
|
| } |
|
| else if ((*(*l_element_courant).donnee).type == CHN) |
|
| { |
|
| chaine_sauvegarde = (unsigned char *) |
|
| (*s_sous_objet).objet; |
|
| |
|
| if (((*s_sous_objet).objet = malloc((strlen( |
|
| chaine_sauvegarde) + 3) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf((unsigned char *) (*s_sous_objet).objet, |
|
| "\"%s\"", chaine_sauvegarde); |
|
| |
|
| free(chaine_sauvegarde); |
|
| } |
|
| |
|
| if (empilement(s_etat_processus, &((*s_etat_processus) |
|
| .l_base_pile), s_sous_objet) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| } |
} |
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| } |
} |
| |
|
| if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), |
(*longueur_effective) = longueur_champ + 1; |
| &s_sous_objet) == d_erreur) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if ((chaine = (unsigned char *) malloc((strlen((unsigned char *) |
if ((chaine = malloc((*longueur_effective) * sizeof(unsigned char))) |
| (*s_sous_objet).objet) + 2 + 1) * sizeof(unsigned char))) |
|
| == NULL) |
== NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| sprintf(chaine, "'%s'", (unsigned char *) (*s_sous_objet).objet); |
chaine[0] = longueur_champ; |
| liberation(s_etat_processus, s_sous_objet); |
|
| |
for(i = 1; i <= (unsigned) (*longueur_effective); i++) |
| |
{ |
| |
chaine[i] = ((*((logical8 *) (*s_objet).objet)) >> |
| |
(8 * (longueur_champ - i))) & 0xFF; |
| |
} |
| } |
} |
| else if ((*s_objet).type == BIN) |
else if ((*s_objet).type == CHN) |
| { |
{ |
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Entier binaire en base 2, 8, 10 ou 16 |
Chaîne de caractères |
| |
Poids fort 1000 0XXX (longueur inférieure à 2**3-1 |
| |
1000 10LL (autres longueurs) |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if (format_sortie != 'B') |
longueur_reelle_chaine = longueur_chaine(s_etat_processus, |
| { |
(unsigned char *) (*s_objet).objet); |
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| longueur_binaire = longueur_entiers_binaires(s_etat_processus); |
|
| masque_binaire = masque_entiers_binaires(s_etat_processus); |
|
| |
|
| if ((test_cfsf(s_etat_processus, 43) == d_faux) && |
if ((longueur_champ == -1) || (longueur_reelle_chaine < |
| (test_cfsf(s_etat_processus, 44) == d_faux)) |
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 *) |
| -- Base décimale --------------------------------------------------------------- |
(*s_objet).objet, &longueur_chaine_traitee)) == NULL) |
| */ |
{ |
| |
return(NULL); |
| sprintf(tampon, "%llu", (*((logical8 *) |
} |
| ((*s_objet).objet))) & masque_binaire); |
|
| strcpy(base, "d"); |
|
| } |
} |
| else if ((test_cfsf(s_etat_processus, 43) == d_vrai) && |
else |
| (test_cfsf(s_etat_processus, 44) == d_faux)) |
|
| { |
{ |
| |
// Format de type CHARACTER*(n) |
| |
|
| /* |
if ((chaine_sauvegarde = formateur_flux(s_etat_processus, |
| -- Base octale ----------------------------------------------------------------- |
(unsigned char *) (*s_objet).objet, |
| */ |
&longueur_chaine_traitee)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| sprintf(tampon, "%llo", (*((logical8 *) |
if ((chaine = malloc(longueur_champ * sizeof(unsigned char))) |
| ((*s_objet).objet))) & masque_binaire); |
== NULL) |
| strcpy(base, "o"); |
{ |
| } |
(*s_etat_processus).erreur_systeme = |
| else if (test_cfsf(s_etat_processus, 44) == d_vrai) |
d_es_allocation_memoire; |
| { |
return(NULL); |
| |
} |
| |
|
| /* |
memcpy(chaine, chaine_sauvegarde, longueur_champ); |
| -- Bases hexadécimale et binaire ----------------------------------------------- |
longueur_chaine_traitee = longueur_champ; |
| */ |
free(chaine_sauvegarde); |
| |
} |
| |
|
| sprintf(tampon, "%llX", (*((logical8 *) |
chaine_sauvegarde = chaine; |
| ((*s_objet).objet))) & masque_binaire); |
|
| |
|
| if (test_cfsf(s_etat_processus, 43) == d_vrai) |
if (longueur_chaine_traitee < (1LL << 3)) |
| |
{ |
| |
if ((chaine = malloc((longueur_chaine_traitee + 1) |
| |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| strcpy(base, "h"); |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| } |
} |
| else |
|
| { |
|
| chaine = (unsigned char *) malloc((strlen(tampon) + 1) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, tampon); |
chaine[0] = 0x80 | (longueur_chaine_traitee & 0x7); |
| tampon[0] = 0; |
|
| |
|
| for(i = 0; i < strlen(chaine); i++) |
|
| { |
|
| switch(chaine[i]) |
|
| { |
|
| case '0' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0000" : "0"); |
|
| break; |
|
| } |
|
| case '1' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0001" : "1"); |
|
| break; |
|
| } |
|
| case '2' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0010" : "10"); |
|
| break; |
|
| } |
|
| case '3' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0011" : "11"); |
|
| break; |
|
| } |
|
| case '4' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0100" : "100"); |
|
| break; |
|
| } |
|
| case '5' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0101" : "101"); |
|
| break; |
|
| } |
|
| case '6' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0110" : "110"); |
|
| break; |
|
| } |
|
| case '7' : |
|
| { |
|
| strcat(tampon, (i != 0) ? "0111" : "111"); |
|
| break; |
|
| } |
|
| case '8' : |
|
| { |
|
| strcat(tampon, "1000"); |
|
| break; |
|
| } |
|
| case '9' : |
|
| { |
|
| strcat(tampon, "1001"); |
|
| break; |
|
| } |
|
| case 'A' : |
|
| { |
|
| strcat(tampon, "1010"); |
|
| break; |
|
| } |
|
| case 'B' : |
|
| { |
|
| strcat(tampon, "1011"); |
|
| break; |
|
| } |
|
| case 'C' : |
|
| { |
|
| strcat(tampon, "1100"); |
|
| break; |
|
| } |
|
| case 'D' : |
|
| { |
|
| strcat(tampon, "1101"); |
|
| break; |
|
| } |
|
| case 'E' : |
|
| { |
|
| strcat(tampon, "1110"); |
|
| break; |
|
| } |
|
| case 'F' : |
|
| { |
|
| strcat(tampon, "1111"); |
|
| break; |
|
| } |
|
| } |
|
| } |
|
| |
|
| free(chaine); |
memcpy(chaine + 1, chaine_sauvegarde, longueur_chaine_traitee); |
| strcpy(base, "b"); |
longueur_totale = longueur_chaine_traitee + 1; |
| } |
|
| } |
} |
| |
else if (longueur_chaine_traitee < (1LL << 8)) |
| |
{ |
| |
if ((chaine = malloc((longueur_chaine_traitee + 2) |
| |
* sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| chaine = (unsigned char *) malloc((strlen(tampon) + 4) |
chaine[0] = 0x88; |
| * sizeof(unsigned char)); |
chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
| |
|
| if (chaine == NULL) |
memcpy(chaine + 2, chaine_sauvegarde, longueur_chaine_traitee); |
| { |
longueur_totale = longueur_chaine_traitee + 2; |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
} |
| |
else if (longueur_chaine_traitee < (1LL << 16)) |
| |
{ |
| |
if ((chaine = malloc((longueur_chaine_traitee + 3) |
| |
* sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| strcpy(chaine, "# "); |
chaine[0] = 0x89; |
| |
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8) |
| |
& 0xFF); |
| |
chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
| |
|
| strcat(chaine, tampon); |
memcpy(chaine + 3, chaine_sauvegarde, longueur_chaine_traitee); |
| strcat(chaine, base); |
longueur_totale = longueur_chaine_traitee + 3; |
| } |
} |
| else if ((*s_objet).type == CHN) |
else if (longueur_chaine_traitee < (1LL << 32)) |
| { |
{ |
| |
if ((chaine = malloc((longueur_chaine_traitee + 5) |
| |
* sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| /* |
chaine[0] = 0x8A; |
| -------------------------------------------------------------------------------- |
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24) |
| Chaîne de caractères |
& 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); |
| |
|
| if (format_sortie != 'C') |
memcpy(chaine + 5, chaine_sauvegarde, longueur_chaine_traitee); |
| { |
longueur_totale = longueur_chaine_traitee + 5; |
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
} |
| |
else |
| |
{ |
| |
if ((chaine = malloc((longueur_chaine_traitee + 9) |
| |
* sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| chaine = (unsigned char *) malloc((strlen((unsigned char *) |
chaine[0] = 0x8B; |
| ((*s_objet).objet)) + 1) * sizeof(unsigned char)); |
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); |
| |
|
| if (chaine == NULL) |
memcpy(chaine + 9, chaine_sauvegarde, longueur_chaine_traitee); |
| { |
longueur_totale = longueur_chaine_traitee + 9; |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
} |
| |
|
| strcpy(chaine, (unsigned char *) ((*s_objet).objet)); |
(*longueur_effective) = longueur_totale; |
| } |
} |
| else if ((*s_objet).type == CPL) |
else if ((*s_objet).type == CPL) |
| { |
{ |
|
Line 3881 formateur_fichier(struct_processus *s_et
|
Line 3254 formateur_fichier(struct_processus *s_et
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Complexe |
Complexe |
| |
Poids fort 0001 10 |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if (format_sortie != 'C') |
| (format_sortie != 'I') && (format_sortie != 'E')) |
|
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, |
if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus, |
| (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C', |
(*s_objet).objet, 'C', 'C', longueur, longueur_effective)) |
| longueur, longueur_champ, format_sortie)) == NULL) |
== NULL) |
| { |
|
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine = (unsigned char *) malloc((strlen(chaine_formatee) |
|
| + 1) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| else if ((*s_objet).type == RPN) |
|
| { |
|
| |
|
| /* |
|
| -------------------------------------------------------------------------------- |
|
| Définition |
|
| -------------------------------------------------------------------------------- |
|
| */ |
|
| |
|
| l_element_courant = (struct_liste_chainee *) ((*s_objet).objet); |
|
| chaine_sauvegarde = chaine; |
|
| |
|
| while(l_element_courant != NULL) |
|
| { |
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
|
| (*l_element_courant).donnee, s_format, |
|
| longueur, longueur_champ, format_sortie, type, |
|
| longueur_effective, recursivite)) == NULL) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if ((*(*l_element_courant).donnee).type == CHN) |
|
| { |
|
| chaine_tampon = chaine_formatee; |
|
| |
|
| if ((chaine_formatee = (unsigned char *) malloc((strlen( |
|
| chaine_tampon) + 3) * sizeof(unsigned char))) |
|
| == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf(chaine_formatee, "\"%s\"", chaine_tampon); |
|
| free(chaine_tampon); |
|
| } |
|
| |
|
| l_element_courant = (*l_element_courant).suivant; |
|
| |
|
| if (chaine != NULL) |
|
| { |
|
| chaine_sauvegarde = chaine; |
|
| |
|
| if ((chaine = (unsigned char *) malloc((strlen( |
|
| chaine_sauvegarde) + strlen(chaine_formatee) + 2) * |
|
| sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| else |
|
| { |
|
| chaine = chaine_formatee; |
|
| } |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 1) * |
|
| sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| free(chaine_sauvegarde); |
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine_sauvegarde[strlen(chaine_sauvegarde)] = d_code_fin_chaine; |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| } |
} |
| else if ((*s_objet).type == INT) |
else if ((*s_objet).type == INT) |
| { |
{ |
|
Line 3999 formateur_fichier(struct_processus *s_et
|
Line 3278 formateur_fichier(struct_processus *s_et
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Entier |
Entier |
| |
Poids fort 0001 00 |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if (format_sortie != 'I') |
if ((format_sortie != 'I') && (format_sortie != 'R') |
| |
&& (format_sortie != 'C')) |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| switch(longueur) |
if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus, |
| |
(*s_objet).objet, 'I', format_sortie, longueur, |
| |
longueur_effective)) == NULL) |
| { |
{ |
| case 1: |
return(NULL); |
| { |
|
| if ((*((integer8 *) (*s_objet).objet)) != |
|
| ((integer1) (*((integer8 *) (*s_objet).objet)))) |
|
| { |
|
| (*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_totale = 2; |
|
| chaine[0] = 0x10; |
|
| chaine[1] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
| break; |
|
| } |
|
| |
|
| case 2: |
|
| { |
|
| if ((*((integer8 *) (*s_objet).objet)) != |
|
| ((integer2) (*((integer8 *) (*s_objet).objet)))) |
|
| { |
|
| (*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_totale = 3; |
|
| chaine[0] = 0x11; |
|
| chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 8) |
|
| & 0xFF; |
|
| chaine[2] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
| break; |
|
| } |
|
| |
|
| case 4: |
|
| { |
|
| if ((*((integer4 *) (*s_objet).objet)) != |
|
| ((integer2) (*((integer8 *) (*s_objet).objet)))) |
|
| { |
|
| (*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_totale = 5; |
|
| chaine[0] = 0x12; |
|
| chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 24) |
|
| & 0xFF; |
|
| chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 16) |
|
| & 0xFF; |
|
| chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 8) |
|
| & 0xFF; |
|
| chaine[4] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
| break; |
|
| } |
|
| |
|
| case 8: |
|
| { |
|
| if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| longueur_totale = 9; |
|
| chaine[0] = 0x13; |
|
| chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 56) |
|
| & 0xFF; |
|
| chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 48) |
|
| & 0xFF; |
|
| chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 40) |
|
| & 0xFF; |
|
| chaine[4] = ((*((integer8 *) (*s_objet).objet)) >> 32) |
|
| & 0xFF; |
|
| chaine[5] = ((*((integer8 *) (*s_objet).objet)) >> 24) |
|
| & 0xFF; |
|
| chaine[6] = ((*((integer8 *) (*s_objet).objet)) >> 16) |
|
| & 0xFF; |
|
| chaine[7] = ((*((integer8 *) (*s_objet).objet)) >> 8) |
|
| & 0xFF; |
|
| chaine[8] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
| break; |
|
| } |
|
| |
|
| default : |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| } |
} |
| |
|
| (*longueur_effective) = longueur_totale; |
|
| } |
} |
| else if ((*s_objet).type == FCT) |
else if ((*s_objet).type == FCT) |
| { |
{ |
|
Line 4136 formateur_fichier(struct_processus *s_et
|
Line 3306 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| 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) |
else if (((*s_objet).type == LST) || ((*s_objet).type == ALG) |
| |
|| ((*s_objet).type == RPN)) |
| { |
{ |
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Liste |
Liste |
| Poids fort 0100 |
Poids fort 0100 |
| |
|
| |
Expression algébrique |
| |
Poids fort 0111 |
| |
|
| |
Définition |
| |
Poids fort 0110 |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
|
Line 4167 formateur_fichier(struct_processus *s_et
|
Line 3332 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
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. |
// Calcul de la longueur de la liste. |
| |
|
| longueur_liste = 0; |
longueur_liste = 0; |
|
Line 4180 formateur_fichier(struct_processus *s_et
|
Line 3358 formateur_fichier(struct_processus *s_et
|
| |
|
| if (longueur_liste < (1LL << 3)) |
if (longueur_liste < (1LL << 3)) |
| { |
{ |
| chaine[0] = 0x40 | (longueur_liste & 0x7); |
chaine[0] = type_binaire | (longueur_liste & 0x7); |
| } |
} |
| else if (longueur_liste < (1LL << 8)) |
else if (longueur_liste < (1LL << 8)) |
| { |
{ |
| chaine[0] = 0x48; |
chaine[0] = type_binaire | 0x08; |
| } |
} |
| else if (longueur_liste < (1LL << 16)) |
else if (longueur_liste < (1LL << 16)) |
| { |
{ |
| chaine[0] = 0x49; |
chaine[0] = type_binaire | 0x09; |
| } |
} |
| else if (longueur_liste < (1LL << 32)) |
else if (longueur_liste < (1LL << 32)) |
| { |
{ |
| chaine[0] = 0x4A; |
chaine[0] = type_binaire | 0x0A; |
| } |
} |
| else |
else |
| { |
{ |
| chaine[0] = 0x4B; |
chaine[0] = type_binaire | 0x0B; |
| } |
} |
| |
|
| longueur_totale = 1; |
longueur_totale = 1; |
|
Line 4317 formateur_fichier(struct_processus *s_et
|
Line 3495 formateur_fichier(struct_processus *s_et
|
| { |
{ |
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if ((chaine_formatee = formateur_fichier(s_etat_processus, |
| (*l_element_courant).donnee, |
(*l_element_courant).donnee, |
| (*l_element_courant_format).donnee, |
(*l_element_courant_format).donnee, 0, 0, ' ', 'U', |
| 0, 0, ' ', 'U', longueur_effective, recursivite)) |
longueur_effective, recursivite, export_fichier)) |
| == NULL) |
== NULL) |
| { |
{ |
| return(NULL); |
return(NULL); |
|
Line 4357 formateur_fichier(struct_processus *s_et
|
Line 3535 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| format_degenere = d_faux; |
|
| |
|
| if (strncmp("INTEGER*", format_chaine, 8) == 0) |
if (strncmp("INTEGER*", format_chaine, 8) == 0) |
| { |
{ |
| format_sortie = 'I'; |
format_sortie = 'I'; |
|
Line 4379 formateur_fichier(struct_processus *s_et
|
Line 3555 formateur_fichier(struct_processus *s_et
|
| format_sortie = 'C'; |
format_sortie = 'C'; |
| position_1 = 8; |
position_1 = 8; |
| } |
} |
| else if (strcmp("CHARACTER", format_chaine) == 0) |
else if (strncmp("CHARACTER*", format_chaine, 10) == 0) |
| { |
{ |
| format_sortie = 'S'; |
format_sortie = 'S'; |
| position_1 = 10; |
position_1 = 10; |
|
Line 4395 formateur_fichier(struct_processus *s_et
|
Line 3571 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if (format_degenere == d_faux) |
if (format_chaine[position_1] == d_code_fin_chaine) |
| { |
{ |
| if (format_chaine[position_1] == d_code_fin_chaine) |
free(chaine); |
| { |
free(format_chaine); |
| free(chaine); |
|
| free(format_chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| |
if (strcmp(&(format_chaine[position_1]), "(*)") != 0) |
| |
{ |
| if (sscanf(&(format_chaine[position_1]), "%ld", |
if (sscanf(&(format_chaine[position_1]), "%ld", |
| &longueur) != 1) |
&longueur) != 1) |
| { |
{ |
|
Line 4417 formateur_fichier(struct_processus *s_et
|
Line 3593 formateur_fichier(struct_processus *s_et
|
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| |
longueur_champ = longueur; |
| } |
} |
| else |
else |
| { |
{ |
| |
longueur_champ = -1; |
| longueur = -1; |
longueur = -1; |
| } |
} |
| |
|
|
Line 4428 formateur_fichier(struct_processus *s_et
|
Line 3607 formateur_fichier(struct_processus *s_et
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if ((chaine_formatee = formateur_fichier(s_etat_processus, |
| (*l_element_courant).donnee, s_format, |
(*l_element_courant).donnee, s_format, |
| longueur, longueur_champ, format_sortie, type, |
longueur, longueur_champ, format_sortie, type, |
| longueur_effective, recursivite)) == NULL) |
longueur_effective, recursivite, export_fichier)) |
| |
== NULL) |
| { |
{ |
| free(chaine); |
free(chaine); |
| return(NULL); |
return(NULL); |
|
Line 4464 formateur_fichier(struct_processus *s_et
|
Line 3644 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if ((*recursivite) == 1) |
|
| { |
|
| // Ajout de la longueur totale en fin d'enregistrement. |
|
| |
|
| if (longueur_totale < (((integer8) 1) << 6)) |
|
| { |
|
| tampon[0] = longueur_totale + 1; |
|
| |
|
| if ((chaine = realloc(chaine, (longueur_totale + 1) |
|
| * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| memcpy(&(chaine[longueur_totale]), tampon, 1); |
|
| longueur_totale += 1; |
|
| } |
|
| else if (longueur_totale < (((integer8) 1) << 16)) |
|
| { |
|
| tampon[2] = 0x40; |
|
| tampon[1] = (longueur_totale + 1) & 0xFF; |
|
| tampon[0] = ((longueur_totale + 1) >> 8) & 0xFF; |
|
| |
|
| if ((chaine = realloc(chaine, (longueur_totale + 3) |
|
| * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| memcpy(&(chaine[longueur_totale]), tampon, 3); |
|
| longueur_totale += 3; |
|
| } |
|
| else if (longueur_totale < (((integer8) 1) << 32)) |
|
| { |
|
| tampon[4] = 0x80; |
|
| tampon[3] = (longueur_totale + 1) & 0xFF; |
|
| tampon[2] = ((longueur_totale + 1) >> 8) & 0xFF; |
|
| tampon[1] = ((longueur_totale + 1) >> 16) & 0xFF; |
|
| tampon[0] = ((longueur_totale + 1) >> 24) & 0xFF; |
|
| |
|
| if ((chaine = realloc(chaine, (longueur_totale + 5) |
|
| * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| memcpy(&(chaine[longueur_totale]), tampon, 5); |
|
| longueur_totale += 5; |
|
| } |
|
| else |
|
| { |
|
| tampon[8] = 0xC0; |
|
| tampon[7] = (longueur_totale + 1) & 0xFF; |
|
| tampon[6] = ((longueur_totale + 1) >> 8) & 0xFF; |
|
| tampon[5] = ((longueur_totale + 1) >> 16) & 0xFF; |
|
| tampon[4] = ((longueur_totale + 1) >> 24) & 0xFF; |
|
| tampon[3] = ((longueur_totale + 1) >> 32) & 0xFF; |
|
| tampon[2] = ((longueur_totale + 1) >> 40) & 0xFF; |
|
| tampon[1] = ((longueur_totale + 1) >> 48) & 0xFF; |
|
| tampon[0] = ((longueur_totale + 1) >> 56) & 0xFF; |
|
| |
|
| if ((chaine = realloc(chaine, (longueur_totale + 9) |
|
| * sizeof(unsigned char))) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| memcpy(&(chaine[longueur_totale]), tampon, 9); |
|
| longueur_totale += 9; |
|
| } |
|
| |
|
| __zone(); |
|
| } |
|
| |
|
| (*longueur_effective) = longueur_totale; |
(*longueur_effective) = longueur_totale; |
| } |
} |
| else if ((*s_objet).type == TBL) |
else if ((*s_objet).type == TBL) |
|
Line 4556 formateur_fichier(struct_processus *s_et
|
Line 3654 formateur_fichier(struct_processus *s_et
|
| Table |
Table |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((*s_format).type != TBL) |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| l_element_courant = (struct_liste_chainee *) (*s_objet).objet; |
|
| l_element_courant_format = (struct_liste_chainee *) |
|
| (*s_format).objet; |
|
| |
|
| if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements != |
|
| (*((struct_tableau *) (*s_format).objet)).nombre_elements) |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, "<["); |
|
| |
|
| for(i = 0; i < (*((struct_tableau *) (*s_objet).objet)) |
|
| .nombre_elements; i++) |
|
| { |
|
| if ((((*(*((struct_tableau *) (*s_format).objet)) |
|
| .elements[i]).type == LST) && |
|
| ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) |
|
| .type == LST)) || |
|
| (((*(*((struct_tableau *) (*s_format).objet)) |
|
| .elements[i]).type == TBL) && |
|
| ((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) |
|
| .type == TAB))) |
|
| { |
|
| chaine_sauvegarde = chaine; |
|
| |
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
|
| (*l_element_courant).donnee, |
|
| (*l_element_courant_format).donnee, |
|
| 0, 0, ' ', 'F', longueur_effective, recursivite)) |
|
| == NULL) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine = (unsigned char *) malloc((strlen(chaine_formatee) |
|
| + strlen(chaine_sauvegarde) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| else if ((*(*((struct_tableau *) (*s_format).objet)) |
|
| .elements[i]).type != CHN) |
|
| { |
|
| free(chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| else |
|
| { |
|
| if ((format_chaine = conversion_majuscule((unsigned char *) |
|
| (*(*((struct_tableau *) (*s_format).objet)) |
|
| .elements[i]).objet)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| format_degenere = d_faux; |
|
| |
|
| if (strncmp("STANDARD*", format_chaine, 9) == 0) |
|
| { |
|
| format_sortie = 'S'; |
|
| position_1 = 9; |
|
| format_degenere = d_vrai; |
|
| } |
|
| else if (strncmp("BINARY*", format_chaine, 7) == 0) |
|
| { |
|
| format_sortie = 'B'; |
|
| position_1 = 7; |
|
| } |
|
| else if (strncmp("FIXED*", format_chaine, 6) == 0) |
|
| { |
|
| format_sortie = 'F'; |
|
| position_1 = 6; |
|
| } |
|
| else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0) |
|
| { |
|
| format_sortie = 'I'; |
|
| position_1 = 11; |
|
| } |
|
| else if (strncmp("ENGINEER*", format_chaine, 9) == 0) |
|
| { |
|
| format_sortie = 'E'; |
|
| position_1 = 9; |
|
| } |
|
| else if (strncmp("CHARACTER*", format_chaine, 10) == 0) |
|
| { |
|
| format_sortie = 'C'; |
|
| position_1 = 10; |
|
| format_degenere = d_vrai; |
|
| } |
|
| else |
|
| { |
|
| free(chaine); |
|
| free(format_chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| position_3 = strlen(format_chaine); |
|
| format_chaine[--position_3] = d_code_fin_chaine; |
|
| |
|
| position_2 = position_1; |
|
| |
|
| while(format_chaine[position_2] != '(') |
|
| { |
|
| if (format_chaine[position_2] == d_code_fin_chaine) |
|
| { |
|
| free(chaine); |
|
| free(format_chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| position_2++; |
|
| } |
|
| |
|
| format_chaine[position_2++] = d_code_fin_chaine; |
|
| |
|
| if (format_degenere == d_faux) |
|
| { |
|
| if (sscanf(&(format_chaine[position_1]), "%ld", |
|
| &longueur) != 1) |
|
| { |
|
| free(chaine); |
|
| free(format_chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| } |
|
| else |
|
| { |
|
| longueur = -1; |
|
| } |
|
| |
|
| if (strcmp(&(format_chaine[position_2]), "*") != 0) |
|
| { |
|
| if (sscanf(&(format_chaine[position_2]), "%ld", |
|
| &longueur_champ) != 1) |
|
| { |
|
| free(chaine); |
|
| free(format_chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| } |
|
| else |
|
| { |
|
| longueur_champ = -1; |
|
| } |
|
| |
|
| if ((longueur >= 0) && (longueur_champ >= 0) && (longueur > |
|
| longueur_champ)) |
|
| { |
|
| free(chaine); |
|
| free(format_chaine); |
|
| |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| free(format_chaine); |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| |
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
|
| (*((struct_tableau *) (*s_objet).objet)) |
|
| .elements[i], s_format, |
|
| longueur, longueur_champ, format_sortie, type, |
|
| longueur_effective, recursivite)) == NULL) |
|
| { |
|
| return(NULL); |
|
| } |
|
| |
|
| if ((*(*((struct_tableau *) (*s_objet).objet)) |
|
| .elements[i]).type == CHN) |
|
| { |
|
| chaine = (unsigned char *) |
|
| malloc((strlen(chaine_formatee) |
|
| + strlen(chaine_sauvegarde) + 4) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " \""); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| strcat(chaine, "\""); |
|
| } |
|
| else if ((*(*((struct_tableau *) (*s_objet).objet)) |
|
| .elements[i]).type == NOM) |
|
| { |
|
| chaine = (unsigned char *) |
|
| malloc((strlen(chaine_formatee) |
|
| + strlen(chaine_sauvegarde) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf(chaine, "%s %s", chaine_sauvegarde, |
|
| chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| else |
|
| { |
|
| chaine = (unsigned char *) |
|
| malloc((strlen(chaine_formatee) |
|
| + strlen(chaine_sauvegarde) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| } |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) + 4) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]>"); |
|
| } |
} |
| else if ((*s_objet).type == MCX) |
else if ((*s_objet).type == MCX) |
| { |
{ |
|
Line 4858 formateur_fichier(struct_processus *s_et
|
Line 3663 formateur_fichier(struct_processus *s_et
|
| Matrice complexe |
Matrice complexe |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
|
| (format_sortie != 'I') && (format_sortie != 'E')) |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) |
|
| .nombre_lignes; |
|
| nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) |
|
| .nombre_colonnes; |
|
| |
|
| chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); |
|
| |
|
| if (chaine != NULL) |
|
| { |
|
| strcpy(chaine, "[["); |
|
| |
|
| for(i = 0; i < nombre_lignes; i++) |
|
| { |
|
| for(j = 0; j < nombre_colonnes; j++) |
|
| { |
|
| if ((chaine_formatee = |
|
| formateur_fichier_nombre(s_etat_processus, |
|
| (void *) &(((struct_complexe16 **) |
|
| ((*((struct_matrice *) |
|
| ((*s_objet).objet))).tableau))[i][j]), 'C', |
|
| longueur, longueur_champ, format_sortie)) |
|
| == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + |
|
| strlen(chaine_formatee) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| if (test_cfsf(s_etat_processus, 45) == d_vrai) |
|
| { |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + 6) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]\n ["); |
|
| } |
|
| else |
|
| { |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + 4) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]["); |
|
| } |
|
| } |
|
| |
|
| if (test_cfsf(s_etat_processus, 45) == d_vrai) |
|
| { |
|
| chaine[strlen(chaine) - 3] = ']'; |
|
| chaine[strlen(chaine) - 2] = 0; |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) |
|
| + 1) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| } |
|
| else |
|
| { |
|
| chaine[strlen(chaine) - 2] = ']'; |
|
| chaine[strlen(chaine) - 1] = 0; |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) |
|
| + 2) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, "]"); |
|
| } |
|
| } |
|
| } |
} |
| else if ((*s_objet).type == MIN) |
else if ((*s_objet).type == MIN) |
| { |
{ |
|
Line 5001 formateur_fichier(struct_processus *s_et
|
Line 3672 formateur_fichier(struct_processus *s_et
|
| Matrice entière |
Matrice entière |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
|
| (format_sortie != 'I') && (format_sortie != 'E')) |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) |
|
| .nombre_lignes; |
|
| nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) |
|
| .nombre_colonnes; |
|
| |
|
| chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); |
|
| |
|
| if (chaine != NULL) |
|
| { |
|
| strcpy(chaine, "[["); |
|
| |
|
| for(i = 0; i < nombre_lignes; i++) |
|
| { |
|
| for(j = 0; j < nombre_colonnes; j++) |
|
| { |
|
| if ((chaine_formatee = |
|
| formateur_fichier_nombre(s_etat_processus, |
|
| (void *) &(((integer8 **) ((*((struct_matrice *) |
|
| ((*s_objet).objet))).tableau))[i][j]), 'I', |
|
| longueur, longueur_champ, format_sortie)) |
|
| == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + |
|
| strlen(chaine_formatee) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| if (test_cfsf(s_etat_processus, 45) == d_vrai) |
|
| { |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + 6) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]\n ["); |
|
| } |
|
| else |
|
| { |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + 4) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]["); |
|
| } |
|
| } |
|
| |
|
| if (test_cfsf(s_etat_processus, 45) == d_vrai) |
|
| { |
|
| chaine[strlen(chaine) - 3] = ']'; |
|
| chaine[strlen(chaine) - 2] = 0; |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) |
|
| + 1) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| } |
|
| else |
|
| { |
|
| chaine[strlen(chaine) - 2] = ']'; |
|
| chaine[strlen(chaine) - 1] = 0; |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) |
|
| + 2) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, "]"); |
|
| } |
|
| } |
|
| } |
} |
| else if ((*s_objet).type == MRL) |
else if ((*s_objet).type == MRL) |
| { |
{ |
|
Line 5143 formateur_fichier(struct_processus *s_et
|
Line 3681 formateur_fichier(struct_processus *s_et
|
| Matrice réelle |
Matrice réelle |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
|
| (format_sortie != 'I') && (format_sortie != 'E')) |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| nombre_lignes = (*((struct_matrice *) ((*s_objet).objet))) |
|
| .nombre_lignes; |
|
| nombre_colonnes = (*((struct_matrice *) ((*s_objet).objet))) |
|
| .nombre_colonnes; |
|
| |
|
| chaine = (unsigned char *) malloc(3 * sizeof(unsigned char)); |
|
| |
|
| if (chaine != NULL) |
|
| { |
|
| strcpy(chaine, "[["); |
|
| |
|
| for(i = 0; i < nombre_lignes; i++) |
|
| { |
|
| for(j = 0; j < nombre_colonnes; j++) |
|
| { |
|
| if ((chaine_formatee = |
|
| formateur_fichier_nombre(s_etat_processus, |
|
| (void *) &(((real8 **) ((*((struct_matrice *) |
|
| ((*s_objet).objet))).tableau))[i][j]), 'R', |
|
| longueur, longueur_champ, format_sortie)) |
|
| == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + |
|
| strlen(chaine_formatee) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| if (test_cfsf(s_etat_processus, 45) == d_vrai) |
|
| { |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + 6) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]\n ["); |
|
| } |
|
| else |
|
| { |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + 4) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]["); |
|
| } |
|
| } |
|
| |
|
| if (test_cfsf(s_etat_processus, 45) == d_vrai) |
|
| { |
|
| chaine[strlen(chaine) - 3] = ']'; |
|
| chaine[strlen(chaine) - 2] = 0; |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) |
|
| + 1) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| } |
|
| else |
|
| { |
|
| chaine[strlen(chaine) - 2] = ']'; |
|
| chaine[strlen(chaine) - 1] = 0; |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc((strlen(chaine_sauvegarde) |
|
| + 2) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, "]"); |
|
| } |
|
| } |
|
| } |
} |
| else if ((*s_objet).type == NOM) |
else if ((*s_objet).type == NOM) |
| { |
{ |
|
Line 5285 formateur_fichier(struct_processus *s_et
|
Line 3690 formateur_fichier(struct_processus *s_et
|
| Nom |
Nom |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| chaine = (unsigned char *) malloc((strlen((*((struct_nom *) |
|
| (*s_objet).objet)).nom) + 3) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| sprintf(chaine, "'%s'", (*((struct_nom *) (*s_objet).objet)).nom); |
|
| } |
} |
| else if ((*s_objet).type == REL) |
else if ((*s_objet).type == REL) |
| { |
{ |
|
Line 5303 formateur_fichier(struct_processus *s_et
|
Line 3697 formateur_fichier(struct_processus *s_et
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Réel |
Réel |
| |
Poids fort 0001 01 |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
if ((format_sortie != 'R') && (format_sortie != 'C')) |
| (format_sortie != 'I') && (format_sortie != 'E')) |
|
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, |
if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus, |
| (void *) ((real8 *) ((*s_objet).objet)), 'R', |
(*s_objet).objet, 'R', format_sortie, |
| longueur, longueur_champ, format_sortie)) == NULL) |
longueur, longueur_effective)) == 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); |
return(NULL); |
| } |
} |
| |
|
| strcpy(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
} |
| else if ((*s_objet).type == VCX) |
else if ((*s_objet).type == VCX) |
| { |
{ |
|
Line 5342 formateur_fichier(struct_processus *s_et
|
Line 3723 formateur_fichier(struct_processus *s_et
|
| Vecteur complexe |
Vecteur complexe |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
|
| (format_sortie != 'I') && (format_sortie != 'E')) |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
|
| |
|
| nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) |
|
| .taille; |
|
| |
|
| chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); |
|
| |
|
| if (chaine != NULL) |
|
| { |
|
| strcpy(chaine, "["); |
|
| |
|
| for(i = 0; i < nombre_colonnes; i++) |
|
| { |
|
| if ((chaine_formatee = |
|
| formateur_fichier_nombre(s_etat_processus, |
|
| (void *) &(((struct_complexe16 *) |
|
| ((*((struct_vecteur *) |
|
| ((*s_objet).objet))).tableau))[i]), 'C', |
|
| longueur, longueur_champ, format_sortie)) == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + strlen(chaine_formatee) |
|
| + 2) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
|
| chaine = (unsigned char *) malloc( |
|
| (strlen(chaine_sauvegarde) + 3) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
|
| (*s_etat_processus).erreur_systeme = |
|
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " ]"); |
|
| } |
|
| } |
} |
| else if ((*s_objet).type == VIN) |
else if ((*s_objet).type == VIN) |
| { |
{ |
|
Line 5418 formateur_fichier(struct_processus *s_et
|
Line 3732 formateur_fichier(struct_processus *s_et
|
| Vecteur entier |
Vecteur entier |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
} |
| |
else if ((*s_objet).type == VRL) |
| |
{ |
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
/* |
| (format_sortie != 'I') && (format_sortie != 'E')) |
-------------------------------------------------------------------------------- |
| { |
Vecteur réel |
| (*s_etat_processus).erreur_execution = |
-------------------------------------------------------------------------------- |
| d_ex_erreur_format_fichier; |
*/ |
| return(NULL); |
} |
| } |
else |
| |
{ |
| nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) |
// Type non exportable |
| .taille; |
|
| |
|
| chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); |
|
| |
|
| if (chaine != NULL) |
(*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; |
| { |
free(chaine); |
| strcpy(chaine, "["); |
|
| |
|
| for(i = 0; i < nombre_colonnes; i++) |
return(NULL); |
| { |
} |
| 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; |
// On n'ajoute la longueur de l'enregistrement que dans le cas |
| chaine = (unsigned char *) malloc( |
// où le format est utilisé dans un fichier. |
| (strlen(chaine_sauvegarde) + strlen(chaine_formatee) |
|
| + 2) * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
if (((*recursivite) == 1) && (export_fichier == d_vrai)) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
// Ajout de la longueur totale en fin d'enregistrement. |
| d_es_allocation_memoire; |
|
| return(NULL); |
|
| } |
|
| |
|
| strcpy(chaine, chaine_sauvegarde); |
longueur_totale = (*longueur_effective); |
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
|
| |
|
| chaine_sauvegarde = chaine; |
if (longueur_totale < (((integer8) 1) << 7)) |
| chaine = (unsigned char *) malloc( |
{ |
| (strlen(chaine_sauvegarde) + 3) |
tampon[0] = ((longueur_totale + 1) << 1) & 0xFF; |
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
if ((chaine = realloc(chaine, (longueur_totale + 1) |
| |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_allocation_memoire; |
d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| strcpy(chaine, chaine_sauvegarde); |
// XXXX XXX0 |
| free(chaine_sauvegarde); |
memcpy(&(chaine[longueur_totale]), tampon, 1); |
| strcat(chaine, " ]"); |
longueur_totale += 1; |
| } |
|
| } |
|
| else if ((*s_objet).type == VRL) |
|
| { |
|
| |
|
| /* |
|
| -------------------------------------------------------------------------------- |
|
| Vecteur réel |
|
| -------------------------------------------------------------------------------- |
|
| */ |
|
| |
|
| if ((format_sortie != 'S') && (format_sortie != 'F') && |
|
| (format_sortie != 'I') && (format_sortie != 'E')) |
|
| { |
|
| (*s_etat_processus).erreur_execution = |
|
| d_ex_erreur_format_fichier; |
|
| return(NULL); |
|
| } |
} |
| |
else if (longueur_totale < (((integer8) 1) << 16)) |
| nombre_colonnes = (*((struct_vecteur *) ((*s_objet).objet))) |
|
| .taille; |
|
| |
|
| chaine = (unsigned char *) malloc(2 * sizeof(unsigned char)); |
|
| |
|
| if (chaine != NULL) |
|
| { |
{ |
| strcpy(chaine, "["); |
longueur_totale++; |
| |
|
| for(i = 0; i < nombre_colonnes; i++) |
for(i = 0; i < 7; i++) |
| { |
{ |
| if ((chaine_formatee = |
if ((longueur_totale < (((integer8) 1) << (8 * (i + 2)))) |
| formateur_fichier_nombre(s_etat_processus, |
|| (i == 6)) |
| (void *) &(((real8 *) ((*((struct_vecteur *) |
|
| ((*s_objet).objet))).tableau))[i]), 'R', |
|
| longueur, longueur_champ, format_sortie)) == NULL) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
// LSB (4 bits de poids fort) |
| d_es_allocation_memoire; |
tampon[0] = (longueur_totale & 0xF0) |
| return(NULL); |
| 0x1 /* longueur supérieure à 7 bits */ |
| } |
| ((i + 1) << 1); |
| |
|
| chaine_sauvegarde = chaine; |
for(j = 0; j <= i; j++) |
| chaine = (unsigned char *) malloc( |
{ |
| (strlen(chaine_sauvegarde) + strlen(chaine_formatee) |
tampon[(i - j) + 1] = |
| + 2) * sizeof(unsigned char)); |
(longueur_totale >> (8 * (j + 1))) |
| |
& 0xFF; |
| |
} |
| |
|
| if (chaine == NULL) |
// LSB (4 bits de poids faible) |
| { |
tampon[i + 2] = ((longueur_totale & 0x0F) << 4) |
| (*s_etat_processus).erreur_systeme = |
| 0x1 /* longueur supérieure à 7 bits */ |
| d_es_allocation_memoire; |
| ((i + 1) << 1); |
| return(NULL); |
break; |
| } |
} |
| |
|
| strcpy(chaine, chaine_sauvegarde); |
|
| free(chaine_sauvegarde); |
|
| strcat(chaine, " "); |
|
| strcat(chaine, chaine_formatee); |
|
| free(chaine_formatee); |
|
| } |
} |
| |
|
| chaine_sauvegarde = chaine; |
if ((chaine = realloc(chaine, (longueur_totale + 3) |
| chaine = (unsigned char *) malloc( |
* sizeof(unsigned char))) == NULL) |
| (strlen(chaine_sauvegarde) + 3) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_allocation_memoire; |
d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| strcpy(chaine, chaine_sauvegarde); |
memcpy(&(chaine[longueur_totale]), tampon, 3); |
| free(chaine_sauvegarde); |
longueur_totale += 3; |
| strcat(chaine, " ]"); |
} |
| |
else if (longueur_totale < (((integer8) 1) << 32)) |
| |
{ |
| } |
} |
| } |
|
| else |
|
| { |
|
| // Type non exportable |
|
| |
|
| (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; |
|
| free(chaine); |
|
| |
|
| return(NULL); |
__zone(); |
| |
(*longueur_effective) = longueur_totale; |
| } |
} |
| } |
} |
| |
|
|
Line 5733 formateur_fichier_nombre(struct_processu
|
Line 3988 formateur_fichier_nombre(struct_processu
|
| |
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Recherche de la longueur de l'entier minimale pour représenter la donnée |
|
| -------------------------------------------------------------------------------- |
|
| */ |
|
| |
|
| unsigned char |
|
| recherche_longueur_optimale(integer8 parametre) |
|
| { |
|
| if (parametre == (integer8) ((integer1) parametre)) |
|
| { |
|
| return(0x0); |
|
| } |
|
| else if (parametre == (integer8) ((integer2) parametre)) |
|
| { |
|
| return(0x1); |
|
| } |
|
| else if (parametre == (integer8) ((integer4) parametre)) |
|
| { |
|
| return(0x2); |
|
| } |
|
| else |
|
| { |
|
| return(0x3); |
|
| } |
|
| } |
|
| |
|
| |
|
| /* |
|
| -------------------------------------------------------------------------------- |
|
| Formateur des réels et entiers |
Formateur des réels et entiers |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
|
Line 5965 formateur_fichier_reel(struct_processus
|
Line 4192 formateur_fichier_reel(struct_processus
|
| } |
} |
| } |
} |
| } |
} |
| |
|
| strcpy(chaine, tampon); |
strcpy(chaine, tampon); |
| } |
} |
| |
|
|
Line 5983 formateur_fichier_reel(struct_processus
|
Line 4211 formateur_fichier_reel(struct_processus
|
| |
|
| return(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, long longueur, long *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] = 0x10; |
| |
chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF; |
| |
break; |
| |
} |
| |
|
| |
case 2: |
| |
{ |
| |
if ((*((integer8 *) valeur_numerique)) != |
| |
((integer2) (*((integer8 *) valeur_numerique)))) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_representation; |
| |
return(NULL); |
| |
} |
| |
|
| |
if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
(*longueur_conversion) = 3; |
| |
chaine[0] = 0x11; |
| |
chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8) |
| |
& 0xFF; |
| |
chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF; |
| |
break; |
| |
} |
| |
|
| |
case 4: |
| |
{ |
| |
if ((*((integer8 *) valeur_numerique)) != |
| |
((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] = 0x12; |
| |
chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24) |
| |
& 0xFF; |
| |
chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16) |
| |
& 0xFF; |
| |
chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8) |
| |
& 0xFF; |
| |
chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF; |
| |
break; |
| |
} |
| |
|
| |
case 8: |
| |
{ |
| |
if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
(*longueur_conversion) = 9; |
| |
chaine[0] = 0x13; |
| |
chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56) |
| |
& 0xFF; |
| |
chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48) |
| |
& 0xFF; |
| |
chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40) |
| |
& 0xFF; |
| |
chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32) |
| |
& 0xFF; |
| |
chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24) |
| |
& 0xFF; |
| |
chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16) |
| |
& 0xFF; |
| |
chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8) |
| |
& 0xFF; |
| |
chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF; |
| |
break; |
| |
} |
| |
|
| |
default : |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
break; |
| |
} |
| |
|
| |
case 'R' : |
| |
{ |
| |
switch(longueur) |
| |
{ |
| |
case 4: |
| |
{ |
| |
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 = (*((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] = 0x14; |
| |
chaine[1] = (eq4.i4 >> 24) & 0xFF; |
| |
chaine[2] = (eq4.i4 >> 16) & 0xFF; |
| |
chaine[3] = (eq4.i4 >> 8) & 0xFF; |
| |
chaine[4] = eq4.i4 & 0xFF; |
| |
break; |
| |
} |
| |
|
| |
case 8: |
| |
{ |
| |
union |
| |
{ |
| |
real8 r8; |
| |
integer8 i8; |
| |
} eq8; |
| |
|
| |
if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
if (type_entree == 'I') |
| |
{ |
| |
eq8.r8 = (*((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] = 0x15; |
| |
chaine[1] = (eq8.i8 >> 56) & 0xFF; |
| |
chaine[2] = (eq8.i8 >> 48) & 0xFF; |
| |
chaine[3] = (eq8.i8 >> 40) & 0xFF; |
| |
chaine[4] = (eq8.i8 >> 32) & 0xFF; |
| |
chaine[5] = (eq8.i8 >> 24) & 0xFF; |
| |
chaine[6] = (eq8.i8 >> 16) & 0xFF; |
| |
chaine[7] = (eq8.i8 >> 8) & 0xFF; |
| |
chaine[8] = eq8.i8 & 0xFF; |
| |
break; |
| |
} |
| |
|
| |
default : |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
break; |
| |
} |
| |
|
| |
case 'C' : |
| |
{ |
| |
switch(longueur) |
| |
{ |
| |
case 8: |
| |
{ |
| |
unsigned char *partie_reelle; |
| |
unsigned char *partie_imaginaire; |
| |
|
| |
long limag; |
| |
long lreel; |
| |
|
| |
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((lreel + limag - 1) * |
| |
sizeof(unsigned char))) == NULL) |
| |
{ |
| |
free(partie_reelle); |
| |
free(partie_imaginaire); |
| |
|
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = 0x18; |
| |
memcpy(chaine + 1, partie_reelle + 1, lreel - 1); |
| |
memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1); |
| |
(*longueur_conversion) = lreel + limag - 1; |
| |
|
| |
free(partie_reelle); |
| |
free(partie_imaginaire); |
| |
break; |
| |
} |
| |
|
| |
case 16: |
| |
{ |
| |
unsigned char *partie_reelle; |
| |
unsigned char *partie_imaginaire; |
| |
|
| |
long limag; |
| |
long lreel; |
| |
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((lreel + limag - 1) * |
| |
sizeof(unsigned char))) == NULL) |
| |
{ |
| |
free(partie_reelle); |
| |
free(partie_imaginaire); |
| |
|
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = 0x19; |
| |
memcpy(chaine + 1, partie_reelle + 1, lreel - 1); |
| |
memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1); |
| |
(*longueur_conversion) = lreel + limag - 1; |
| |
|
| |
free(partie_reelle); |
| |
free(partie_imaginaire); |
| |
break; |
| |
} |
| |
|
| |
default : |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
break; |
| |
} |
| |
|
| |
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; |
| |
|
| |
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(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 * ((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); |
| |
} |
| |
|
| |
(*((integer8 *) (*s_objet).objet)) = 0; |
| |
|
| |
for(i = 0; i < (signed) deplacement; i++) |
| |
{ |
| |
(*((integer8 *) (*s_objet).objet)) |= |
| |
((integer8) octets[i]) |
| |
<< (8 * ((deplacement - 1) - i)); |
| |
} |
| |
|
| |
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 * ((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 * ((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 * ((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; |
| |
} |
| |
|
| |
default: |
| |
{ |
| |
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
break; |
| |
} |
| |
|
| |
case 0x40: // Liste |
| |
{ |
| |
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, LST)) == 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(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; |
| |
} |
| |
|
| |
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 = ((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 |
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to formateur_fichiers.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / src