|
version 1.54, 2013/03/11 11:07:24
|
version 1.78, 2014/07/17 08:07:17
|
|
Line 1
|
Line 1
|
| /* |
/* |
| ================================================================================ |
================================================================================ |
| RPL/2 (R) version 4.1.13 |
RPL/2 (R) version 4.1.19 |
| Copyright (C) 1989-2013 Dr. BERTRAND Joël |
Copyright (C) 1989-2014 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 40
|
Line 40
|
| |
|
| unsigned char * |
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, integer8 longueur, integer8 longueur_champ, |
| unsigned char format_sortie, unsigned char type, |
unsigned char format_sortie, unsigned char type, |
| long *longueur_effective, long *recursivite, logical1 export_fichier) |
integer8 *longueur_effective, integer8 *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 63 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 72 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*n" "character*(*)" } |
* "character*n" "character*(*)" "native*(*)" } |
| */ |
*/ |
| |
|
| logical1 autorisation_parenthese; |
logical1 autorisation_parenthese; |
| logical1 format_degenere; |
logical1 format_degenere; |
| 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; |
| struct_liste_chainee *l_liste1; |
struct_liste_chainee *l_liste1; |
| struct_liste_chainee *l_liste2; |
struct_liste_chainee *l_liste2; |
| |
|
| |
struct_objet *s_format_tmp; |
| struct_objet *s_sous_objet; |
struct_objet *s_sous_objet; |
| struct_objet *s_sous_objet_1; |
struct_objet *s_sous_objet_1; |
| struct_objet *s_sous_objet_2; |
struct_objet *s_sous_objet_2; |
|
Line 102 formateur_fichier(struct_processus *s_et
|
Line 103 formateur_fichier(struct_processus *s_et
|
| unsigned char tampon[64 + 1]; |
unsigned char tampon[64 + 1]; |
| unsigned char type_binaire; |
unsigned char type_binaire; |
| |
|
| unsigned long i; |
integer8 i; |
| unsigned long j; |
integer8 j; |
| unsigned long nombre_arguments; |
integer8 nombre_arguments; |
| unsigned long nombre_arguments_fonction; |
integer8 nombre_arguments_fonction; |
| unsigned long nombre_colonnes; |
integer8 nombre_colonnes; |
| unsigned long nombre_elements; |
integer8 nombre_elements; |
| unsigned long nombre_lignes; |
integer8 nombre_lignes; |
| |
|
| |
integer8 longueur_chaine_traitee; |
| |
integer8 longueur_fonction; |
| integer8 longueur_liste; |
integer8 longueur_liste; |
| integer8 longueur_reelle_chaine; |
integer8 longueur_reelle_chaine; |
| 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; |
|
Line 132 formateur_fichier(struct_processus *s_et
|
Line 134 formateur_fichier(struct_processus *s_et
|
| |
|
| strcpy(base, " "); |
strcpy(base, " "); |
| |
|
| masque_binaire = 0; |
|
| |
|
| if ((*s_objet).type == ALG) |
if ((*s_objet).type == ALG) |
| { |
{ |
| |
|
|
Line 143 formateur_fichier(struct_processus *s_et
|
Line 143 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 922 formateur_fichier(struct_processus *s_et
|
Line 929 formateur_fichier(struct_processus *s_et
|
| ptrl = chaine_sauvegarde; |
ptrl = chaine_sauvegarde; |
| ptre = (unsigned char *) (*s_sous_objet).objet; |
ptre = (unsigned char *) (*s_sous_objet).objet; |
| |
|
| for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0; |
for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde)) |
| i--, *ptre++ = *ptrl++); |
- 2; i > 0; i--, *ptre++ = *ptrl++); |
| |
|
| (*ptre) = d_code_fin_chaine; |
(*ptre) = d_code_fin_chaine; |
| |
|
|
Line 985 formateur_fichier(struct_processus *s_et
|
Line 992 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if (format_sortie != 'B') |
if ((format_sortie != 'B') && (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); |
| } |
} |
| |
|
| masque_binaire = masque_entiers_binaires(s_etat_processus); |
if (format_sortie == 'N') |
| |
|
| if ((test_cfsf(s_etat_processus, 43) == d_faux) && |
|
| (test_cfsf(s_etat_processus, 44) == d_faux)) |
|
| { |
{ |
| |
sprintf(tampon, "%llX", (unsigned long long) (*((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", (unsigned long long) |
| |
(*((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 < ((integer8) 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", (*((unsigned long long *) |
| d_es_allocation_memoire; |
((*s_objet).objet)))); |
| return(NULL); |
strcpy(base, "o"); |
| |
break; |
| } |
} |
| |
|
| strcpy(chaine, tampon); |
case 10: |
| tampon[0] = 0; |
{ |
| |
sprintf(tampon, "%llu", (*((unsigned long long *) |
| |
((*s_objet).objet)))); |
| |
strcpy(base, "d"); |
| |
break; |
| |
} |
| |
|
| for(i = 0; i < strlen(chaine); i++) |
case 16: |
| { |
{ |
| switch(chaine[i]) |
sprintf(tampon, "%llX", (unsigned long long) |
| { |
(*((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[((integer8) strlen(tampon)) |
| |
- longueur_champ]); |
| |
ptre = tampon; |
| |
|
| |
do |
| |
{ |
| |
*ptre++ = *ptrl++; |
| |
} while((*ptrl) != d_code_fin_chaine); |
| |
|
| |
(*ptre) = d_code_fin_chaine; |
| } |
} |
| } |
} |
| |
|
|
Line 1162 formateur_fichier(struct_processus *s_et
|
Line 1193 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| if (format_sortie != 'C') |
if ((format_sortie != 'C') && (format_sortie != 'N')) |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
|
Line 1172 formateur_fichier(struct_processus *s_et
|
Line 1203 formateur_fichier(struct_processus *s_et
|
| longueur_reelle_chaine = longueur_chaine(s_etat_processus, |
longueur_reelle_chaine = longueur_chaine(s_etat_processus, |
| (unsigned char *) (*s_objet).objet); |
(unsigned char *) (*s_objet).objet); |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
longueur_champ = -1; |
| |
} |
| |
|
| if ((longueur_champ == -1) || (longueur_reelle_chaine < |
if ((longueur_champ == -1) || (longueur_reelle_chaine < |
| longueur_champ)) |
longueur_champ)) |
| { |
{ |
|
Line 1194 formateur_fichier(struct_processus *s_et
|
Line 1230 formateur_fichier(struct_processus *s_et
|
| (*s_objet).objet, longueur_champ) |
(*s_objet).objet, longueur_champ) |
| - ((unsigned char *) (*s_objet).objet); |
- ((unsigned char *) (*s_objet).objet); |
| |
|
| if ((chaine = malloc((longueur_reelle_chaine + 1) * |
if ((chaine = malloc((((size_t) longueur_reelle_chaine) + 1) * |
| sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 1203 formateur_fichier(struct_processus *s_et
|
Line 1239 formateur_fichier(struct_processus *s_et
|
| } |
} |
| |
|
| strncpy(chaine, (unsigned char *) ((*s_objet).objet), |
strncpy(chaine, (unsigned char *) ((*s_objet).objet), |
| longueur_reelle_chaine); |
(size_t) longueur_reelle_chaine); |
| chaine[longueur_reelle_chaine] = d_code_fin_chaine; |
chaine[longueur_reelle_chaine] = d_code_fin_chaine; |
| } |
} |
| } |
} |
|
Line 1216 formateur_fichier(struct_processus *s_et
|
Line 1252 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 1253 formateur_fichier(struct_processus *s_et
|
Line 1294 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 1335 formateur_fichier(struct_processus *s_et
|
Line 1383 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 1425 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 1479 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, |
|
| export_fichier)) == 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 1574 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 1590 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| position_3 = strlen(format_chaine) - 1; |
position_3 = ((integer8) strlen(format_chaine)) - 1; |
| |
|
| if (format_chaine[position_3] != ')') |
if (format_chaine[position_3] != ')') |
| { |
{ |
|
Line 1543 formateur_fichier(struct_processus *s_et
|
Line 1625 formateur_fichier(struct_processus *s_et
|
| |
|
| if (format_degenere == d_faux) |
if (format_degenere == d_faux) |
| { |
{ |
| if (sscanf(&(format_chaine[position_1]), "%ld", |
if (sscanf(&(format_chaine[position_1]), "%lld", |
| &longueur) != 1) |
&longueur) != 1) |
| { |
{ |
| free(chaine); |
free(chaine); |
|
Line 1561 formateur_fichier(struct_processus *s_et
|
Line 1643 formateur_fichier(struct_processus *s_et
|
| |
|
| if (strcmp(&(format_chaine[position_2]), "*") != 0) |
if (strcmp(&(format_chaine[position_2]), "*") != 0) |
| { |
{ |
| if (sscanf(&(format_chaine[position_2]), "%ld", |
if (sscanf(&(format_chaine[position_2]), "%lld", |
| &longueur_champ) != 1) |
&longueur_champ) != 1) |
| { |
{ |
| free(chaine); |
free(chaine); |
|
Line 1578 formateur_fichier(struct_processus *s_et
|
Line 1660 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 1592 formateur_fichier(struct_processus *s_et
|
Line 1674 formateur_fichier(struct_processus *s_et
|
| |
|
| chaine_sauvegarde = chaine; |
chaine_sauvegarde = chaine; |
| |
|
| |
// Si le format_sortie vaut 'N', on remplace le format par |
| |
// { "native*(*)" }. L'intérêt est de pouvoir traiter une |
| |
// liste par un format "native*(*)". |
| |
|
| |
if ((format_sortie == 'N') && ((*(*l_element_courant) |
| |
.donnee).type == LST)) |
| |
{ |
| |
if ((s_format_tmp = allocation(s_etat_processus, LST)) |
| |
== NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
if (((*s_format_tmp).objet = allocation_maillon( |
| |
s_etat_processus)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
(*((struct_liste_chainee *) (*s_format_tmp).objet)) |
| |
.suivant = NULL; |
| |
|
| |
if (((*((struct_liste_chainee *) (*s_format_tmp).objet)) |
| |
.donnee = allocation(s_etat_processus, CHN)) |
| |
== NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
if (((*(*((struct_liste_chainee *) (*s_format_tmp) |
| |
.objet)).donnee).objet = malloc(11 * |
| |
sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
strcpy((unsigned char *) (*(*((struct_liste_chainee *) |
| |
(*s_format_tmp).objet)).donnee).objet, |
| |
"native*(*)"); |
| |
} |
| |
else |
| |
{ |
| |
if ((s_format_tmp = copie_objet(s_etat_processus, |
| |
s_format, 'P')) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
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, export_fichier)) |
longueur_effective, recursivite, export_fichier)) |
| == NULL) |
== NULL) |
| { |
{ |
| |
liberation(s_etat_processus, s_format_tmp); |
| free(chaine); |
free(chaine); |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| |
liberation(s_etat_processus, s_format_tmp); |
| |
|
| if ((*(*l_element_courant).donnee).type == CHN) |
if ((*(*l_element_courant).donnee).type == CHN) |
| { |
{ |
| chaine = (unsigned char *) |
chaine = (unsigned char *) |
|
Line 1665 formateur_fichier(struct_processus *s_et
|
Line 1801 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 1701 formateur_fichier(struct_processus *s_et
|
Line 1849 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 1733 formateur_fichier(struct_processus *s_et
|
Line 1881 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 == TBL))) |
|
| { |
{ |
| 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) && |
| export_fichier)) == NULL) |
((*(*((struct_tableau *) (*s_objet).objet)) |
| { |
.elements[i]).type == TBL))) |
| return(NULL); |
|
| } |
|
| |
|
| chaine = (unsigned char *) malloc((strlen(chaine_formatee) |
|
| + strlen(chaine_sauvegarde) + 2) |
|
| * sizeof(unsigned char)); |
|
| |
|
| if (chaine == NULL) |
|
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
chaine_sauvegarde = chaine; |
| 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) |
else if ((*(*((struct_tableau *) (*s_format).objet)) |
| { |
.elements[i]).type != CHN) |
| format_sortie = 'C'; |
|
| position_1 = 10; |
|
| format_degenere = d_vrai; |
|
| } |
|
| else |
|
| { |
{ |
| 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 1851 formateur_fichier(struct_processus *s_et
|
Line 1992 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| position_2++; |
position_3 = (integer8) 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]), "%lld", |
| |
&longueur) != 1) |
| |
{ |
| |
free(chaine); |
| |
free(format_chaine); |
| |
|
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
longueur = -1; |
| |
} |
| |
|
| |
if (strcmp(&(format_chaine[position_2]), "*") != 0) |
| |
{ |
| |
if (sscanf(&(format_chaine[position_2]), "%lld", |
| |
&longueur_champ) != 1) |
| |
{ |
| |
free(chaine); |
| |
free(format_chaine); |
| |
|
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
longueur_champ = -1; |
| |
} |
| |
|
| |
if ((longueur >= 0) && (longueur_champ >= 0) && |
| |
(longueur > longueur_champ)) |
| { |
{ |
| free(chaine); |
free(chaine); |
| free(format_chaine); |
free(format_chaine); |
|
Line 1886 formateur_fichier(struct_processus *s_et
|
Line 2060 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, export_fichier)) |
longueur_effective, recursivite, |
| == NULL) |
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 2004 formateur_fichier(struct_processus *s_et
|
Line 2177 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 2147 formateur_fichier(struct_processus *s_et
|
Line 2325 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 2289 formateur_fichier(struct_processus *s_et
|
Line 2472 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 2431 formateur_fichier(struct_processus *s_et
|
Line 2619 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 2451 formateur_fichier(struct_processus *s_et
|
Line 2646 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 2488 formateur_fichier(struct_processus *s_et
|
Line 2688 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 2564 formateur_fichier(struct_processus *s_et
|
Line 2769 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 2639 formateur_fichier(struct_processus *s_et
|
Line 2849 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 2715 formateur_fichier(struct_processus *s_et
|
Line 2930 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| (*longueur_effective) = strlen(chaine) + 1; |
(*longueur_effective) = ((integer8) strlen(chaine)) + 1; |
| } |
} |
| else |
else |
| { |
{ |
|
Line 2873 formateur_fichier(struct_processus *s_et
|
Line 3088 formateur_fichier(struct_processus *s_et
|
| * 1101 10 11 matrice complex*16 (dimensions integer*4) |
* 1101 10 11 matrice complex*16 (dimensions integer*4) |
| * 1101 11 11 matrice complex*16 (dimensions integer*8) |
* 1101 11 11 matrice complex*16 (dimensions integer*8) |
| * |
* |
| |
* 1110 0 XXX fonction de longueur XXX |
| |
* 1110 10 LL fonction de longueur integer*LL |
| |
* |
| * Les longueurs indiquées par le champ LL suivent l'en-tête : |
* Les longueurs indiquées par le champ LL suivent l'en-tête : |
| * 00 : integer*1 |
* 00 : integer*1 |
| * 01 : integer*2 |
* 01 : integer*2 |
|
Line 2899 formateur_fichier(struct_processus *s_et
|
Line 3117 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'L'; |
| |
longueur_champ = 8; |
| |
} |
| |
|
| if (format_sortie != 'L') |
if (format_sortie != 'L') |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
|
Line 2919 formateur_fichier(struct_processus *s_et
|
Line 3143 formateur_fichier(struct_processus *s_et
|
| |
|
| (*longueur_effective) = longueur_champ + 1; |
(*longueur_effective) = longueur_champ + 1; |
| |
|
| if ((chaine = malloc((*longueur_effective) * sizeof(unsigned char))) |
if ((chaine = malloc(((size_t) (*longueur_effective)) |
| == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = longueur_champ; |
chaine[0] = (unsigned char) longueur_champ; |
| |
|
| for(i = 1; i <= (unsigned) (*longueur_effective); i++) |
for(i = 1; i <= (*longueur_effective); i++) |
| { |
{ |
| chaine[i] = ((*((logical8 *) (*s_objet).objet)) >> |
chaine[i] = ((*((logical8 *) (*s_objet).objet)) >> |
| (8 * (longueur_champ - i))) & 0xFF; |
(8 * (longueur_champ - i))) & 0xFF; |
|
Line 2945 formateur_fichier(struct_processus *s_et
|
Line 3169 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'S'; |
| |
longueur_champ = -1; |
| |
} |
| |
|
| |
if (format_sortie != 'S') |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
|
| longueur_reelle_chaine = longueur_chaine(s_etat_processus, |
longueur_reelle_chaine = longueur_chaine(s_etat_processus, |
| (unsigned char *) (*s_objet).objet); |
(unsigned char *) (*s_objet).objet); |
| |
|
|
Line 2971 formateur_fichier(struct_processus *s_et
|
Line 3208 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if ((chaine = malloc(longueur_champ * sizeof(unsigned char))) |
if ((chaine = malloc(((size_t) longueur_champ) |
| == NULL) |
* 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); |
| } |
} |
| |
|
| memcpy(chaine, chaine_sauvegarde, longueur_champ); |
memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ); |
| longueur_chaine_traitee = longueur_champ; |
longueur_chaine_traitee = longueur_champ; |
| free(chaine_sauvegarde); |
free(chaine_sauvegarde); |
| } |
} |
|
Line 2988 formateur_fichier(struct_processus *s_et
|
Line 3225 formateur_fichier(struct_processus *s_et
|
| |
|
| if (longueur_chaine_traitee < (1LL << 3)) |
if (longueur_chaine_traitee < (1LL << 3)) |
| { |
{ |
| if ((chaine = malloc((longueur_chaine_traitee + 1) |
if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 2996 formateur_fichier(struct_processus *s_et
|
Line 3233 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = 0x80 | (longueur_chaine_traitee & 0x7); |
chaine[0] = (unsigned char) (0x80 | |
| |
(longueur_chaine_traitee & 0x7)); |
| |
|
| memcpy(chaine + 1, chaine_sauvegarde, longueur_chaine_traitee); |
memcpy(chaine + 1, chaine_sauvegarde, |
| |
(size_t) longueur_chaine_traitee); |
| longueur_totale = longueur_chaine_traitee + 1; |
longueur_totale = longueur_chaine_traitee + 1; |
| } |
} |
| else if (longueur_chaine_traitee < (1LL << 8)) |
else if (longueur_chaine_traitee < (1LL << 8)) |
| { |
{ |
| if ((chaine = malloc((longueur_chaine_traitee + 2) |
if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3011 formateur_fichier(struct_processus *s_et
|
Line 3250 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = 0x88; |
chaine[0] = (unsigned char) 0x88; |
| chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
| |
|
| memcpy(chaine + 2, chaine_sauvegarde, longueur_chaine_traitee); |
memcpy(chaine + 2, chaine_sauvegarde, |
| |
(size_t) longueur_chaine_traitee); |
| longueur_totale = longueur_chaine_traitee + 2; |
longueur_totale = longueur_chaine_traitee + 2; |
| } |
} |
| else if (longueur_chaine_traitee < (1LL << 16)) |
else if (longueur_chaine_traitee < (1LL << 16)) |
| { |
{ |
| if ((chaine = malloc((longueur_chaine_traitee + 3) |
if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3027 formateur_fichier(struct_processus *s_et
|
Line 3267 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = 0x89; |
chaine[0] = (unsigned char) 0x89; |
| chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8) |
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8) |
| & 0xFF); |
& 0xFF); |
| chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
| |
|
| memcpy(chaine + 3, chaine_sauvegarde, longueur_chaine_traitee); |
memcpy(chaine + 3, chaine_sauvegarde, |
| |
(size_t) longueur_chaine_traitee); |
| longueur_totale = longueur_chaine_traitee + 3; |
longueur_totale = longueur_chaine_traitee + 3; |
| } |
} |
| else if (longueur_chaine_traitee < (1LL << 32)) |
else if (longueur_chaine_traitee < (1LL << 32)) |
| { |
{ |
| if ((chaine = malloc((longueur_chaine_traitee + 5) |
if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3045 formateur_fichier(struct_processus *s_et
|
Line 3286 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = 0x8A; |
chaine[0] = (unsigned char) 0x8A; |
| chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24) |
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24) |
| & 0xFF); |
& 0xFF); |
| chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16) |
chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16) |
|
Line 3054 formateur_fichier(struct_processus *s_et
|
Line 3295 formateur_fichier(struct_processus *s_et
|
| & 0xFF); |
& 0xFF); |
| chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
| |
|
| memcpy(chaine + 5, chaine_sauvegarde, longueur_chaine_traitee); |
memcpy(chaine + 5, chaine_sauvegarde, |
| |
(size_t) longueur_chaine_traitee); |
| longueur_totale = longueur_chaine_traitee + 5; |
longueur_totale = longueur_chaine_traitee + 5; |
| } |
} |
| else |
else |
| { |
{ |
| if ((chaine = malloc((longueur_chaine_traitee + 9) |
if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3067 formateur_fichier(struct_processus *s_et
|
Line 3309 formateur_fichier(struct_processus *s_et
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = 0x8B; |
chaine[0] = (unsigned char) 0x8B; |
| chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56) |
chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56) |
| & 0xFF); |
& 0xFF); |
| chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48) |
chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48) |
|
Line 3084 formateur_fichier(struct_processus *s_et
|
Line 3326 formateur_fichier(struct_processus *s_et
|
| & 0xFF); |
& 0xFF); |
| chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF); |
| |
|
| memcpy(chaine + 9, chaine_sauvegarde, longueur_chaine_traitee); |
memcpy(chaine + 9, chaine_sauvegarde, |
| |
(size_t) longueur_chaine_traitee); |
| longueur_totale = longueur_chaine_traitee + 9; |
longueur_totale = longueur_chaine_traitee + 9; |
| } |
} |
| |
|
|
Line 3100 formateur_fichier(struct_processus *s_et
|
Line 3343 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'C'; |
| |
longueur = 8; |
| |
} |
| |
|
| if (format_sortie != 'C') |
if (format_sortie != 'C') |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
|
Line 3124 formateur_fichier(struct_processus *s_et
|
Line 3373 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'I'; |
| |
longueur = 8; |
| |
} |
| |
|
| if ((format_sortie != 'I') && (format_sortie != 'R') |
if ((format_sortie != 'I') && (format_sortie != 'R') |
| && (format_sortie != 'C')) |
&& (format_sortie != 'C')) |
| { |
{ |
|
Line 3145 formateur_fichier(struct_processus *s_et
|
Line 3400 formateur_fichier(struct_processus *s_et
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Fonction |
Fonction |
| |
Poids fort 1110 |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie != 'N') |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
|
| |
longueur_fonction = (integer8) strlen((*((struct_fonction *) |
| |
(*s_objet).objet)).nom_fonction); |
| |
|
| |
if (longueur_fonction < (1LL << 3)) |
| |
{ |
| |
if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7)); |
| |
|
| |
strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet)) |
| |
.nom_fonction); |
| |
(*longueur_effective) = 1 + longueur_fonction + 8; |
| |
} |
| |
else if (longueur_fonction < (1LL << 8)) |
| |
{ |
| |
if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0xE0 | 0x08); |
| |
chaine[1] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet)) |
| |
.nom_fonction); |
| |
(*longueur_effective) = 2 + longueur_fonction + 8; |
| |
} |
| |
else if (longueur_fonction < (1LL << 16)) |
| |
{ |
| |
if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char ) (0xE0 | 0x09); |
| |
chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF); |
| |
chaine[2] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet)) |
| |
.nom_fonction); |
| |
(*longueur_effective) = 3 + longueur_fonction + 9; |
| |
} |
| |
else if (longueur_fonction < (1LL << 32)) |
| |
{ |
| |
if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0xE0 | 0x0A); |
| |
chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF); |
| |
chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF); |
| |
chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF); |
| |
chaine[4] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet)) |
| |
.nom_fonction); |
| |
(*longueur_effective) = 5 + longueur_fonction + 8; |
| |
} |
| |
else |
| |
{ |
| |
if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0xE0 | 0x0B); |
| |
chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF); |
| |
chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF); |
| |
chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF); |
| |
chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF); |
| |
chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF); |
| |
chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF); |
| |
chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF); |
| |
chaine[8] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet)) |
| |
.nom_fonction); |
| |
(*longueur_effective) = 9 + longueur_fonction + 8; |
| |
} |
| |
|
| |
for(i = 1; i <= 8; i++) |
| |
{ |
| |
chaine[(*longueur_effective) - i] = (unsigned char) |
| |
(((*((struct_fonction *) (*s_objet).objet)) |
| |
.nombre_arguments >> ((8 - i) * 8)) & 0xFF); |
| |
} |
| } |
} |
| else if (((*s_objet).type == LST) || ((*s_objet).type == ALG) |
else if (((*s_objet).type == LST) || ((*s_objet).type == ALG) |
| || ((*s_objet).type == RPN)) |
|| ((*s_objet).type == RPN)) |
|
Line 3200 formateur_fichier(struct_processus *s_et
|
Line 3568 formateur_fichier(struct_processus *s_et
|
| |
|
| if (longueur_liste < (1LL << 3)) |
if (longueur_liste < (1LL << 3)) |
| { |
{ |
| chaine[0] = type_binaire | (longueur_liste & 0x7); |
chaine[0] = (unsigned char) (type_binaire | |
| |
(longueur_liste & 0x7)); |
| } |
} |
| else if (longueur_liste < (1LL << 8)) |
else if (longueur_liste < (1LL << 8)) |
| { |
{ |
| chaine[0] = type_binaire | 0x08; |
chaine[0] = (unsigned char) (type_binaire | 0x08); |
| } |
} |
| else if (longueur_liste < (1LL << 16)) |
else if (longueur_liste < (1LL << 16)) |
| { |
{ |
| chaine[0] = type_binaire | 0x09; |
chaine[0] = (unsigned char ) (type_binaire | 0x09); |
| } |
} |
| else if (longueur_liste < (1LL << 32)) |
else if (longueur_liste < (1LL << 32)) |
| { |
{ |
| chaine[0] = type_binaire | 0x0A; |
chaine[0] = (unsigned char) (type_binaire | 0x0A); |
| } |
} |
| else |
else |
| { |
{ |
| chaine[0] = type_binaire | 0x0B; |
chaine[0] = (unsigned char) (type_binaire | 0x0B); |
| } |
} |
| |
|
| longueur_totale = 1; |
longueur_totale = 1; |
|
Line 3229 formateur_fichier(struct_processus *s_et
|
Line 3598 formateur_fichier(struct_processus *s_et
|
| { |
{ |
| longueur_totale += 1; |
longueur_totale += 1; |
| |
|
| if ((chaine = realloc(chaine, longueur_totale * |
if ((chaine = realloc(chaine, |
| |
((size_t) longueur_totale) * |
| sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3246 formateur_fichier(struct_processus *s_et
|
Line 3616 formateur_fichier(struct_processus *s_et
|
| { |
{ |
| longueur_totale += 2; |
longueur_totale += 2; |
| |
|
| if ((chaine = realloc(chaine, longueur_totale * |
if ((chaine = realloc(chaine, |
| |
((size_t) longueur_totale) * |
| sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3265 formateur_fichier(struct_processus *s_et
|
Line 3636 formateur_fichier(struct_processus *s_et
|
| { |
{ |
| longueur_totale += 4; |
longueur_totale += 4; |
| |
|
| if ((chaine = realloc(chaine, longueur_totale * |
if ((chaine = realloc(chaine, |
| |
((size_t) longueur_totale) * |
| sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3288 formateur_fichier(struct_processus *s_et
|
Line 3660 formateur_fichier(struct_processus *s_et
|
| { |
{ |
| longueur_totale += 8; |
longueur_totale += 8; |
| |
|
| if ((chaine = realloc(chaine, longueur_totale * |
if ((chaine = realloc(chaine, |
| |
((size_t) longueur_totale) * |
| sizeof(unsigned char))) == NULL) |
sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3335 formateur_fichier(struct_processus *s_et
|
Line 3708 formateur_fichier(struct_processus *s_et
|
| (((*(*l_element_courant_format).donnee).type == TBL) |
(((*(*l_element_courant_format).donnee).type == TBL) |
| && ((*(*l_element_courant).donnee).type == TBL))) |
&& ((*(*l_element_courant).donnee).type == TBL))) |
| { |
{ |
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if (format_sortie != 'N') |
| (*l_element_courant).donnee, |
|
| (*l_element_courant_format).donnee, 0, 0, ' ', 'U', |
|
| longueur_effective, recursivite, export_fichier)) |
|
| == NULL) |
|
| { |
{ |
| return(NULL); |
if ((chaine_formatee = formateur_fichier( |
| |
s_etat_processus, |
| |
(*l_element_courant).donnee, |
| |
(*l_element_courant_format).donnee, |
| |
0, 0, ' ', 'U', longueur_effective, recursivite, |
| |
export_fichier)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((chaine_formatee = formateur_fichier( |
| |
s_etat_processus, |
| |
(*l_element_courant).donnee, |
| |
(*l_element_courant_format).donnee, |
| |
0, 0, 'N', 'U', longueur_effective, recursivite, |
| |
export_fichier)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| } |
} |
| |
|
| if ((chaine = realloc(chaine, (longueur_totale + |
if ((chaine = realloc(chaine, ((size_t) (longueur_totale + |
| (*longueur_effective)) * sizeof(unsigned char))) |
(*longueur_effective))) * sizeof(unsigned char))) |
| == NULL) |
== NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3354 formateur_fichier(struct_processus *s_et
|
Line 3743 formateur_fichier(struct_processus *s_et
|
| } |
} |
| |
|
| memcpy(&(chaine[longueur_totale]), chaine_formatee, |
memcpy(&(chaine[longueur_totale]), chaine_formatee, |
| (*longueur_effective)); |
(size_t) (*longueur_effective)); |
| longueur_totale += (*longueur_effective); |
longueur_totale += (*longueur_effective); |
| free(chaine_formatee); |
free(chaine_formatee); |
| } |
} |
|
Line 3403 formateur_fichier(struct_processus *s_et
|
Line 3792 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 3425 formateur_fichier(struct_processus *s_et
|
Line 3820 formateur_fichier(struct_processus *s_et
|
| |
|
| if (strcmp(&(format_chaine[position_1]), "(*)") != 0) |
if (strcmp(&(format_chaine[position_1]), "(*)") != 0) |
| { |
{ |
| if (sscanf(&(format_chaine[position_1]), "%ld", |
if (sscanf(&(format_chaine[position_1]), "%lld", |
| &longueur) != 1) |
&longueur) != 1) |
| { |
{ |
| free(chaine); |
free(chaine); |
|
Line 3445 formateur_fichier(struct_processus *s_et
|
Line 3840 formateur_fichier(struct_processus *s_et
|
| } |
} |
| |
|
| free(format_chaine); |
free(format_chaine); |
| |
|
| |
// Si le format_sortie vaut 'N', on remplace le format par |
| |
// { "native*(*)" }. L'intérêt est de pouvoir traiter une |
| |
// liste par un format "native*(*)". |
| |
|
| |
if ((format_sortie == 'N') && ((*(*l_element_courant) |
| |
.donnee).type == LST)) |
| |
{ |
| |
if ((s_format_tmp = allocation(s_etat_processus, LST)) |
| |
== NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
if (((*s_format_tmp).objet = allocation_maillon( |
| |
s_etat_processus)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
(*((struct_liste_chainee *) (*s_format_tmp).objet)) |
| |
.suivant = NULL; |
| |
|
| |
if (((*((struct_liste_chainee *) (*s_format_tmp).objet)) |
| |
.donnee = allocation(s_etat_processus, CHN)) |
| |
== NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
|
| |
if (((*(*((struct_liste_chainee *) (*s_format_tmp) |
| |
.objet)).donnee).objet = malloc(11 * |
| |
sizeof(unsigned char))) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
strcpy((unsigned char *) (*(*((struct_liste_chainee *) |
| |
(*s_format_tmp).objet)).donnee).objet, |
| |
"native*(*)"); |
| |
} |
| |
else |
| |
{ |
| |
if ((s_format_tmp = copie_objet(s_etat_processus, |
| |
s_format, 'P')) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| if ((chaine_formatee = formateur_fichier(s_etat_processus, |
if ((chaine_formatee = formateur_fichier(s_etat_processus, |
| (*l_element_courant).donnee, s_format, |
(*l_element_courant).donnee, s_format_tmp, |
| longueur, longueur_champ, format_sortie, type, |
longueur, longueur_champ, format_sortie, type, |
| longueur_effective, recursivite, export_fichier)) |
longueur_effective, recursivite, export_fichier)) |
| == NULL) |
== NULL) |
| { |
{ |
| |
liberation(s_etat_processus, s_format_tmp); |
| free(chaine); |
free(chaine); |
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| |
liberation(s_etat_processus, s_format_tmp); |
| |
|
| if ((chaine = realloc(chaine, |
if ((chaine = realloc(chaine, |
| (longueur_totale + (*longueur_effective)) |
((size_t) (longueur_totale + (*longueur_effective))) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3466 formateur_fichier(struct_processus *s_et
|
Line 3915 formateur_fichier(struct_processus *s_et
|
| } |
} |
| |
|
| memcpy(&(chaine[longueur_totale]), chaine_formatee, |
memcpy(&(chaine[longueur_totale]), chaine_formatee, |
| (*longueur_effective)); |
(size_t) (*longueur_effective)); |
| longueur_totale += (*longueur_effective); |
longueur_totale += (*longueur_effective); |
| free(chaine_formatee); |
free(chaine_formatee); |
| } |
} |
| |
|
| |
if (format_sortie != 'N') |
| |
{ |
| |
l_element_courant_format = |
| |
(*l_element_courant_format).suivant; |
| |
} |
| |
|
| 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 ((l_element_courant != NULL) || |
if (format_sortie != 'N') |
| (l_element_courant_format != NULL)) |
|
| { |
{ |
| 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); |
| |
} |
| } |
} |
| |
|
| (*longueur_effective) = longueur_totale; |
(*longueur_effective) = longueur_totale; |
|
Line 3530 formateur_fichier(struct_processus *s_et
|
Line 3987 formateur_fichier(struct_processus *s_et
|
| /* |
/* |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| Nom |
Nom |
| |
Poids fort 0101 |
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
if (format_sortie != 'N') |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_erreur_format_fichier; |
| |
return(NULL); |
| |
} |
| |
|
| |
longueur_fonction = (integer8) strlen((*((struct_nom *) |
| |
(*s_objet).objet)).nom); |
| |
|
| |
if (longueur_fonction < (1LL << 3)) |
| |
{ |
| |
if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0x50 | (longueur_fonction & 0x7)); |
| |
|
| |
strcpy(chaine + 1, (*((struct_nom *) (*s_objet).objet)).nom); |
| |
(*longueur_effective) = longueur_fonction + 2; |
| |
} |
| |
else if (longueur_fonction < (1LL << 8)) |
| |
{ |
| |
if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 1) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0x50 | 0x08); |
| |
chaine[1] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 2, (*((struct_nom *) (*s_objet).objet)).nom); |
| |
(*longueur_effective) = longueur_fonction + 3; |
| |
} |
| |
else if (longueur_fonction < (1LL << 16)) |
| |
{ |
| |
if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0x50 | 0x09); |
| |
chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF); |
| |
chaine[2] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 3, (*((struct_nom *) (*s_objet).objet)).nom); |
| |
(*longueur_effective) = longueur_fonction + 4; |
| |
} |
| |
else if (longueur_fonction < (1LL << 32)) |
| |
{ |
| |
if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0xE0 | 0x0A); |
| |
chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF); |
| |
chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF); |
| |
chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF); |
| |
chaine[4] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 5, (*((struct_nom *) (*s_objet).objet)).nom); |
| |
(*longueur_effective) = longueur_fonction + 6; |
| |
} |
| |
else |
| |
{ |
| |
if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1) |
| |
* sizeof(unsigned char)))== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
chaine[0] = (unsigned char) (0xE0 | 0x0B); |
| |
chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF); |
| |
chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF); |
| |
chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF); |
| |
chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF); |
| |
chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF); |
| |
chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF); |
| |
chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF); |
| |
chaine[8] = (unsigned char) (longueur_fonction & 0xFF); |
| |
|
| |
strcpy(chaine + 9, (*((struct_nom *) (*s_objet).objet)).nom); |
| |
(*longueur_effective) = longueur_fonction + 10; |
| |
} |
| |
|
| |
chaine[(*longueur_effective) - 1] = ((*((struct_nom *) |
| |
(*s_objet).objet)).symbole == d_vrai) ? 0xFF : 0x00; |
| } |
} |
| else if ((*s_objet).type == REL) |
else if ((*s_objet).type == REL) |
| { |
{ |
|
Line 3543 formateur_fichier(struct_processus *s_et
|
Line 4104 formateur_fichier(struct_processus *s_et
|
| -------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
| */ |
*/ |
| |
|
| |
if (format_sortie == 'N') |
| |
{ |
| |
format_sortie = 'R'; |
| |
longueur = 8; |
| |
} |
| |
|
| if ((format_sortie != 'R') && (format_sortie != 'C')) |
if ((format_sortie != 'R') && (format_sortie != 'C')) |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
|
Line 3605 formateur_fichier(struct_processus *s_et
|
Line 4172 formateur_fichier(struct_processus *s_et
|
| |
|
| if (longueur_totale < (((integer8) 1) << 7)) |
if (longueur_totale < (((integer8) 1) << 7)) |
| { |
{ |
| tampon[0] = ((longueur_totale + 1) << 1) & 0xFF; |
tampon[0] = (unsigned char) (((longueur_totale + 1) << 1) |
| |
& 0xFF); |
| |
|
| if ((chaine = realloc(chaine, (longueur_totale + 1) |
if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3619 formateur_fichier(struct_processus *s_et
|
Line 4187 formateur_fichier(struct_processus *s_et
|
| memcpy(&(chaine[longueur_totale]), tampon, 1); |
memcpy(&(chaine[longueur_totale]), tampon, 1); |
| longueur_totale += 1; |
longueur_totale += 1; |
| } |
} |
| else if (longueur_totale < (((integer8) 1) << 16)) |
else |
| { |
{ |
| longueur_totale++; |
longueur_totale++; |
| |
|
| for(i = 0; i < 7; i++) |
// i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) } |
| |
|
| |
i = 0; |
| |
|
| |
for(;;) |
| { |
{ |
| if ((longueur_totale < (((integer8) 1) << (8 * (i + 2)))) |
if ((longueur_totale < (((integer8) 1) << (8 * (i + 2)))) |
| || (i == 6)) |
|| (i == 6)) |
| { |
{ |
| // LSB (4 bits de poids fort) |
// LSB (4 bits de poids fort) |
| tampon[0] = (longueur_totale & 0xF0) |
tampon[0] = (unsigned char) ((longueur_totale & 0xF0) |
| | 0x1 /* longueur supérieure à 7 bits */ |
| 0x1 /* longueur supérieure à 7 bits */ |
| | ((i + 1) << 1); |
| ((i + 1) << 1)); |
| |
|
| for(j = 0; j <= i; j++) |
for(j = 0; j <= i; j++) |
| { |
{ |
| tampon[(i - j) + 1] = |
tampon[(i - j) + 1] = (unsigned char) |
| (longueur_totale >> (8 * (j + 1))) |
((longueur_totale >> (8 * (j + 1))) |
| & 0xFF; |
& 0xFF); |
| } |
} |
| |
|
| // LSB (4 bits de poids faible) |
// LSB (4 bits de poids faible) |
| tampon[i + 2] = ((longueur_totale & 0x0F) << 4) |
tampon[i + 2] = (unsigned char) |
| |
(((longueur_totale & 0x0F) << 4) |
| | 0x1 /* longueur supérieure à 7 bits */ |
| 0x1 /* longueur supérieure à 7 bits */ |
| | ((i + 1) << 1); |
| ((i + 1) << 1)); |
| break; |
break; |
| } |
} |
| |
|
| |
switch(i) |
| |
{ |
| |
case 0 : |
| |
{ |
| |
i = 2; |
| |
break; |
| |
} |
| |
|
| |
case 2 : |
| |
{ |
| |
i = 6; |
| |
break; |
| |
} |
| |
} |
| } |
} |
| |
|
| if ((chaine = realloc(chaine, (longueur_totale + 3) |
// i = 0 => +3 (16 bits) |
| |
// i = 2 => +5 (32 bits) |
| |
// i = 6 => +9 (64 bits) |
| |
|
| |
if ((chaine = realloc(chaine, (((size_t) longueur_totale) |
| |
+ ((i == 0) ? 3 : ((i == 2) ? 5 : 9))) |
| * sizeof(unsigned char))) == NULL) |
* sizeof(unsigned char))) == NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
|
Line 3659 formateur_fichier(struct_processus *s_et
|
Line 4252 formateur_fichier(struct_processus *s_et
|
| memcpy(&(chaine[longueur_totale]), tampon, 3); |
memcpy(&(chaine[longueur_totale]), tampon, 3); |
| longueur_totale += 3; |
longueur_totale += 3; |
| } |
} |
| else if (longueur_totale < (((integer8) 1) << 32)) |
|
| { |
|
| } |
|
| |
|
| __zone(); |
__zone(); |
| (*longueur_effective) = longueur_totale; |
(*longueur_effective) = longueur_totale; |
|
Line 3697 formateur_fichier(struct_processus *s_et
|
Line 4287 formateur_fichier(struct_processus *s_et
|
| unsigned char * |
unsigned char * |
| formateur_fichier_nombre(struct_processus *s_etat_processus, |
formateur_fichier_nombre(struct_processus *s_etat_processus, |
| void *valeur_numerique, unsigned char type, |
void *valeur_numerique, unsigned char type, |
| long longueur, long longueur_champ, unsigned char format) |
integer8 longueur, integer8 longueur_champ, unsigned char format) |
| { |
{ |
| unsigned char *chaine; |
unsigned char *chaine; |
| unsigned char *construction_chaine; |
unsigned char *construction_chaine; |
|
Line 3837 formateur_fichier_nombre(struct_processu
|
Line 4427 formateur_fichier_nombre(struct_processu
|
| unsigned char * |
unsigned char * |
| formateur_fichier_reel(struct_processus *s_etat_processus, |
formateur_fichier_reel(struct_processus *s_etat_processus, |
| void *valeur_numerique, unsigned char type, |
void *valeur_numerique, unsigned char type, |
| long longueur, long longueur_champ, |
integer8 longueur, integer8 longueur_champ, |
| unsigned char format_sortie) |
unsigned char format_sortie) |
| { |
{ |
| real8 mantisse; |
real8 mantisse; |
| real8 tampon_reel; |
real8 tampon_reel; |
| |
|
| |
integer8 i; |
| integer8 tampon_entier; |
integer8 tampon_entier; |
| |
|
| long correction; |
long correction; |
|
Line 3855 formateur_fichier_reel(struct_processus
|
Line 4446 formateur_fichier_reel(struct_processus
|
| unsigned char mode[3 + 1]; |
unsigned char mode[3 + 1]; |
| unsigned char tampon[16 + 1]; |
unsigned char tampon[16 + 1]; |
| |
|
| unsigned long i; |
|
| |
|
| chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char)); |
chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char)); |
| |
|
| if (chaine == NULL) |
if (chaine == NULL) |
|
Line 3882 formateur_fichier_reel(struct_processus
|
Line 4471 formateur_fichier_reel(struct_processus
|
| exposant = 0; |
exposant = 0; |
| } |
} |
| |
|
| mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant); |
mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant); |
| } |
} |
| else |
else |
| { |
{ |
|
Line 3890 formateur_fichier_reel(struct_processus
|
Line 4479 formateur_fichier_reel(struct_processus
|
| |
|
| if (tampon_entier > ((integer8) 0)) |
if (tampon_entier > ((integer8) 0)) |
| { |
{ |
| exposant = (long) floor(log10(tampon_entier)); |
exposant = (long) floor(log10((double) tampon_entier)); |
| } |
} |
| else if (tampon_entier < ((integer8) 0)) |
else if (tampon_entier < ((integer8) 0)) |
| { |
{ |
| exposant = (long) floor(log10(-tampon_entier)); |
exposant = (long) floor(log10((double) -tampon_entier)); |
| } |
} |
| else |
else |
| { |
{ |
| exposant = 0; |
exposant = 0; |
| } |
} |
| |
|
| mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant); |
mantisse = ((real8) (*((integer8 *) valeur_numerique))) / |
| |
pow(10, (double) exposant); |
| } |
} |
| |
|
| longueur_utile = longueur; |
longueur_utile = (long) longueur; |
| longueur_utile_limite = 15; |
longueur_utile_limite = 15; |
| |
|
| if (longueur_utile > longueur_utile_limite) |
if (longueur_utile > longueur_utile_limite) |
|
Line 3965 formateur_fichier_reel(struct_processus
|
Line 4555 formateur_fichier_reel(struct_processus
|
| |
|
| sprintf(format, "%%.%luf", longueur_utile); |
sprintf(format, "%%.%luf", longueur_utile); |
| |
|
| sprintf(tampon, format, (mantisse * pow(10, exposant))); |
sprintf(tampon, format, (mantisse * pow(10, (double) exposant))); |
| strcpy(chaine, tampon); |
strcpy(chaine, tampon); |
| } |
} |
| else if (strcmp(mode, "ENG") == 0) |
else if (strcmp(mode, "ENG") == 0) |
|
Line 3988 formateur_fichier_reel(struct_processus
|
Line 4578 formateur_fichier_reel(struct_processus
|
| longueur_utile -= correction; |
longueur_utile -= correction; |
| sprintf(format, "%%.%luf", longueur_utile); |
sprintf(format, "%%.%luf", longueur_utile); |
| |
|
| sprintf(tampon, format, (mantisse * pow(10, correction))); |
sprintf(tampon, format, (mantisse * pow(10, (double) correction))); |
| strcpy(chaine, tampon); |
strcpy(chaine, tampon); |
| strcat(chaine, "E"); |
strcat(chaine, "E"); |
| sprintf(tampon, "%ld", (exposant - correction)); |
sprintf(tampon, "%ld", (exposant - correction)); |
|
Line 4018 formateur_fichier_reel(struct_processus
|
Line 4608 formateur_fichier_reel(struct_processus
|
| |
|
| sprintf(tampon, format, *((real8 *) valeur_numerique)); |
sprintf(tampon, format, *((real8 *) valeur_numerique)); |
| |
|
| i = strlen(tampon) - 1; |
i = (integer8) (strlen(tampon)) - 1; |
| while(tampon[i] == '0') |
while(tampon[i] == '0') |
| { |
{ |
| tampon[i] = 0; |
tampon[i] = 0; |
|
Line 4027 formateur_fichier_reel(struct_processus
|
Line 4617 formateur_fichier_reel(struct_processus
|
| |
|
| if (ds_imposition_separateur_decimal == d_faux) |
if (ds_imposition_separateur_decimal == d_faux) |
| { |
{ |
| i = strlen(tampon) - 1; |
i = ((integer8) strlen(tampon)) - 1; |
| if (tampon[i] == '.') |
if (tampon[i] == '.') |
| { |
{ |
| tampon[i] = 0; |
tampon[i] = 0; |
|
Line 4042 formateur_fichier_reel(struct_processus
|
Line 4632 formateur_fichier_reel(struct_processus
|
| { |
{ |
| if (strlen(chaine) > (size_t) longueur_champ) |
if (strlen(chaine) > (size_t) longueur_champ) |
| { |
{ |
| for(i = 0; i < (unsigned long) longueur_champ; i++) |
for(i = 0; i < longueur_champ; i++) |
| { |
{ |
| chaine[i] = '*'; |
chaine[i] = '*'; |
| } |
} |
|
Line 4064 formateur_fichier_reel(struct_processus
|
Line 4654 formateur_fichier_reel(struct_processus
|
| unsigned char * |
unsigned char * |
| formateur_fichier_binaire_nombre(struct_processus *s_etat_processus, |
formateur_fichier_binaire_nombre(struct_processus *s_etat_processus, |
| void *valeur_numerique, unsigned char type_entree, |
void *valeur_numerique, unsigned char type_entree, |
| unsigned char type, long longueur, long *longueur_conversion) |
unsigned char type, integer8 longueur, integer8 *longueur_conversion) |
| { |
{ |
| unsigned char *chaine; |
unsigned char *chaine; |
| |
|
|
Line 4098 formateur_fichier_binaire_nombre(struct_
|
Line 4688 formateur_fichier_binaire_nombre(struct_
|
| } |
} |
| |
|
| (*longueur_conversion) = 2; |
(*longueur_conversion) = 2; |
| chaine[0] = 0x10; |
chaine[0] = (unsigned char) 0x10; |
| chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF; |
chaine[1] = (unsigned char) ((*((integer8 *) |
| |
valeur_numerique)) & 0xFF); |
| break; |
break; |
| } |
} |
| |
|
|
Line 4121 formateur_fichier_binaire_nombre(struct_
|
Line 4712 formateur_fichier_binaire_nombre(struct_
|
| } |
} |
| |
|
| (*longueur_conversion) = 3; |
(*longueur_conversion) = 3; |
| chaine[0] = 0x11; |
chaine[0] = (unsigned char) 0x11; |
| chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8) |
chaine[1] = ((unsigned char) ((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 8) & 0xFF); |
| chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF; |
chaine[2] = (unsigned char) ((*((integer8 *) |
| |
valeur_numerique)) & 0xFF); |
| break; |
break; |
| } |
} |
| |
|
| case 4: |
case 4: |
| { |
{ |
| if ((*((integer8 *) valeur_numerique)) != |
if ((*((integer8 *) valeur_numerique)) != |
| ((integer2) (*((integer8 *) valeur_numerique)))) |
((integer4) (*((integer8 *) valeur_numerique)))) |
| { |
{ |
| (*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
| d_ex_representation; |
d_ex_representation; |
|
Line 4146 formateur_fichier_binaire_nombre(struct_
|
Line 4738 formateur_fichier_binaire_nombre(struct_
|
| } |
} |
| |
|
| (*longueur_conversion) = 5; |
(*longueur_conversion) = 5; |
| chaine[0] = 0x12; |
chaine[0] = (unsigned char) 0x12; |
| chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24) |
chaine[1] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 24) & 0xFF); |
| chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16) |
chaine[2] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 16) & 0xFF); |
| chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8) |
chaine[3] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 8) & 0xFF); |
| chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF; |
chaine[4] = (unsigned char) ((*((integer8 *) |
| |
valeur_numerique)) & 0xFF); |
| break; |
break; |
| } |
} |
| |
|
|
Line 4167 formateur_fichier_binaire_nombre(struct_
|
Line 4760 formateur_fichier_binaire_nombre(struct_
|
| } |
} |
| |
|
| (*longueur_conversion) = 9; |
(*longueur_conversion) = 9; |
| chaine[0] = 0x13; |
chaine[0] = (unsigned char) 0x13; |
| chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56) |
chaine[1] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 56) & 0xFF); |
| chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48) |
chaine[2] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 48) & 0xFF); |
| chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40) |
chaine[3] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 40) & 0xFF); |
| chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32) |
chaine[4] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 32) & 0xFF); |
| chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24) |
chaine[5] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 24) & 0xFF); |
| chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16) |
chaine[6] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 16) & 0xFF); |
| chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8) |
chaine[7] = (unsigned char) (((*((integer8 *) |
| & 0xFF; |
valeur_numerique)) >> 8) & 0xFF); |
| chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF; |
chaine[8] = (unsigned char) ((*((integer8 *) |
| |
valeur_numerique)) & 0xFF); |
| break; |
break; |
| } |
} |
| |
|
|
Line 4219 formateur_fichier_binaire_nombre(struct_
|
Line 4813 formateur_fichier_binaire_nombre(struct_
|
| } |
} |
| else if (type_entree == 'I') |
else if (type_entree == 'I') |
| { |
{ |
| valeur = (*((integer8 *) valeur_numerique)); |
valeur = (real8) (*((integer8 *) valeur_numerique)); |
| } |
} |
| else |
else |
| { |
{ |
|
Line 4256 formateur_fichier_binaire_nombre(struct_
|
Line 4850 formateur_fichier_binaire_nombre(struct_
|
| |
|
| eq4.r4 = (real4) valeur; |
eq4.r4 = (real4) valeur; |
| (*longueur_conversion) = 5; |
(*longueur_conversion) = 5; |
| chaine[0] = 0x14; |
chaine[0] = (unsigned char) 0x14; |
| chaine[1] = (eq4.i4 >> 24) & 0xFF; |
chaine[1] = (unsigned char) ((eq4.i4 >> 24) & 0xFF); |
| chaine[2] = (eq4.i4 >> 16) & 0xFF; |
chaine[2] = (unsigned char) ((eq4.i4 >> 16) & 0xFF); |
| chaine[3] = (eq4.i4 >> 8) & 0xFF; |
chaine[3] = (unsigned char) ((eq4.i4 >> 8) & 0xFF); |
| chaine[4] = eq4.i4 & 0xFF; |
chaine[4] = (unsigned char) (eq4.i4 & 0xFF); |
| break; |
break; |
| } |
} |
| |
|
|
Line 4281 formateur_fichier_binaire_nombre(struct_
|
Line 4875 formateur_fichier_binaire_nombre(struct_
|
| |
|
| if (type_entree == 'I') |
if (type_entree == 'I') |
| { |
{ |
| eq8.r8 = (*((integer8 *) valeur_numerique)); |
eq8.r8 = (real8) (*((integer8 *) valeur_numerique)); |
| } |
} |
| else if (type_entree == 'R') |
else if (type_entree == 'R') |
| { |
{ |
|
Line 4295 formateur_fichier_binaire_nombre(struct_
|
Line 4889 formateur_fichier_binaire_nombre(struct_
|
| } |
} |
| |
|
| (*longueur_conversion) = 9; |
(*longueur_conversion) = 9; |
| chaine[0] = 0x15; |
chaine[0] = (unsigned char) (0x15); |
| chaine[1] = (eq8.i8 >> 56) & 0xFF; |
chaine[1] = (unsigned char) ((eq8.i8 >> 56) & 0xFF); |
| chaine[2] = (eq8.i8 >> 48) & 0xFF; |
chaine[2] = (unsigned char) ((eq8.i8 >> 48) & 0xFF); |
| chaine[3] = (eq8.i8 >> 40) & 0xFF; |
chaine[3] = (unsigned char) ((eq8.i8 >> 40) & 0xFF); |
| chaine[4] = (eq8.i8 >> 32) & 0xFF; |
chaine[4] = (unsigned char) ((eq8.i8 >> 32) & 0xFF); |
| chaine[5] = (eq8.i8 >> 24) & 0xFF; |
chaine[5] = (unsigned char) ((eq8.i8 >> 24) & 0xFF); |
| chaine[6] = (eq8.i8 >> 16) & 0xFF; |
chaine[6] = (unsigned char) ((eq8.i8 >> 16) & 0xFF); |
| chaine[7] = (eq8.i8 >> 8) & 0xFF; |
chaine[7] = (unsigned char) ((eq8.i8 >> 8) & 0xFF); |
| chaine[8] = eq8.i8 & 0xFF; |
chaine[8] = (unsigned char) (eq8.i8 & 0xFF); |
| break; |
break; |
| } |
} |
| |
|
|
Line 4327 formateur_fichier_binaire_nombre(struct_
|
Line 4921 formateur_fichier_binaire_nombre(struct_
|
| unsigned char *partie_reelle; |
unsigned char *partie_reelle; |
| unsigned char *partie_imaginaire; |
unsigned char *partie_imaginaire; |
| |
|
| long limag; |
integer8 limag; |
| long lreel; |
integer8 lreel; |
| |
|
| real8 zero; |
real8 zero; |
| |
|
|
Line 4401 formateur_fichier_binaire_nombre(struct_
|
Line 4995 formateur_fichier_binaire_nombre(struct_
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if ((chaine = malloc((lreel + limag - 1) * |
if ((chaine = malloc((((size_t) lreel) + ((size_t) limag) |
| sizeof(unsigned char))) == NULL) |
- 1) * sizeof(unsigned char))) == NULL) |
| { |
{ |
| free(partie_reelle); |
free(partie_reelle); |
| free(partie_imaginaire); |
free(partie_imaginaire); |
|
Line 4412 formateur_fichier_binaire_nombre(struct_
|
Line 5006 formateur_fichier_binaire_nombre(struct_
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = 0x18; |
chaine[0] = (unsigned char) 0x18; |
| memcpy(chaine + 1, partie_reelle + 1, lreel - 1); |
memcpy(chaine + 1, partie_reelle + 1, |
| memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1); |
((size_t) lreel) - 1); |
| |
memcpy(chaine + lreel, partie_imaginaire + 1, |
| |
((size_t) limag) - 1); |
| (*longueur_conversion) = lreel + limag - 1; |
(*longueur_conversion) = lreel + limag - 1; |
| |
|
| free(partie_reelle); |
free(partie_reelle); |
|
Line 4427 formateur_fichier_binaire_nombre(struct_
|
Line 5023 formateur_fichier_binaire_nombre(struct_
|
| unsigned char *partie_reelle; |
unsigned char *partie_reelle; |
| unsigned char *partie_imaginaire; |
unsigned char *partie_imaginaire; |
| |
|
| long limag; |
integer8 limag; |
| long lreel; |
integer8 lreel; |
| |
|
| real8 zero; |
real8 zero; |
| |
|
| if (type_entree == 'I') |
if (type_entree == 'I') |
|
Line 4500 formateur_fichier_binaire_nombre(struct_
|
Line 5097 formateur_fichier_binaire_nombre(struct_
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| if ((chaine = malloc((lreel + limag - 1) * |
if ((chaine = malloc((((size_t) lreel) + ((size_t) limag) |
| sizeof(unsigned char))) == NULL) |
- 1) * sizeof(unsigned char))) == NULL) |
| { |
{ |
| free(partie_reelle); |
free(partie_reelle); |
| free(partie_imaginaire); |
free(partie_imaginaire); |
|
Line 4511 formateur_fichier_binaire_nombre(struct_
|
Line 5108 formateur_fichier_binaire_nombre(struct_
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| chaine[0] = 0x19; |
chaine[0] = (unsigned char) 0x19; |
| memcpy(chaine + 1, partie_reelle + 1, lreel - 1); |
memcpy(chaine + 1, partie_reelle + 1, |
| memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1); |
((size_t) lreel) - 1); |
| |
memcpy(chaine + lreel, partie_imaginaire + 1, |
| |
((size_t) limag) - 1); |
| (*longueur_conversion) = lreel + limag - 1; |
(*longueur_conversion) = lreel + limag - 1; |
| |
|
| free(partie_reelle); |
free(partie_reelle); |
|
Line 4577 lecture_fichier_non_formate(struct_proce
|
Line 5176 lecture_fichier_non_formate(struct_proce
|
| unsigned char *buffer; |
unsigned char *buffer; |
| unsigned char *flux; |
unsigned char *flux; |
| unsigned char *ptr; |
unsigned char *ptr; |
| |
unsigned char type_objet; |
| |
|
| size_t deplacement; |
size_t deplacement; |
| |
|
|
Line 4588 lecture_fichier_non_formate(struct_proce
|
Line 5188 lecture_fichier_non_formate(struct_proce
|
| } |
} |
| else |
else |
| { |
{ |
| buffer = argument; |
buffer = (*((unsigned char **) argument)); |
| ptr = buffer; |
ptr = buffer; |
| fichier = NULL; |
fichier = NULL; |
| } |
} |
|
Line 4623 lecture_fichier_non_formate(struct_proce
|
Line 5223 lecture_fichier_non_formate(struct_proce
|
| } |
} |
| } |
} |
| |
|
| switch(octets[0] & 0xF0) |
switch(type_objet = (octets[0] & 0xF0)) |
| { |
{ |
| case 0x00: // Binaire |
case 0x00: // Binaire |
| { |
{ |
|
Line 4707 lecture_fichier_non_formate(struct_proce
|
Line 5307 lecture_fichier_non_formate(struct_proce
|
| for(i = 0; i < (signed) deplacement; i++) |
for(i = 0; i < (signed) deplacement; i++) |
| { |
{ |
| (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i]) |
(*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i]) |
| << (8 * ((deplacement - 1) - i)); |
<< (8 * ((((signed) deplacement) - 1) - i)); |
| } |
} |
| |
|
| break; |
break; |
|
Line 4787 lecture_fichier_non_formate(struct_proce
|
Line 5387 lecture_fichier_non_formate(struct_proce
|
| return(NULL); |
return(NULL); |
| } |
} |
| |
|
| (*((integer8 *) (*s_objet).objet)) = 0; |
// Récupération des données avec extension de signe. |
| |
|
| for(i = 0; i < (signed) deplacement; i++) |
|
| { |
{ |
| (*((integer8 *) (*s_objet).objet)) |= |
integer1 i1; |
| ((integer8) octets[i]) |
integer2 i2; |
| << (8 * ((deplacement - 1) - i)); |
integer4 i4; |
| |
integer8 i8; |
| |
|
| |
i1 = 0; |
| |
i2 = 0; |
| |
i4 = 0; |
| |
i8 = 0; |
| |
|
| |
for(i = 0; i < (signed) deplacement; i++) |
| |
{ |
| |
switch(deplacement) |
| |
{ |
| |
case 1: |
| |
i1 = (integer1) octets[0]; |
| |
break; |
| |
|
| |
case 2: |
| |
i2 |= (integer2) (((integer8) octets[i]) << |
| |
(8 * ((((signed) deplacement) - 1) |
| |
- i))); |
| |
break; |
| |
|
| |
case 4: |
| |
i4 |= (integer4) (((integer8) octets[i]) << |
| |
(8 * ((((signed) deplacement) - 1) |
| |
- i))); |
| |
break; |
| |
|
| |
case 8: |
| |
i8 |= (integer8) (((integer8) octets[i]) << |
| |
(8 * ((((signed) deplacement) - 1) |
| |
- i))); |
| |
break; |
| |
} |
| |
} |
| |
|
| |
switch(deplacement) |
| |
{ |
| |
case 1: |
| |
(*((integer8 *) (*s_objet).objet)) = |
| |
(integer8) i1; |
| |
break; |
| |
|
| |
case 2: |
| |
(*((integer8 *) (*s_objet).objet)) = |
| |
(integer8) i2; |
| |
break; |
| |
|
| |
case 4: |
| |
(*((integer8 *) (*s_objet).objet)) = |
| |
(integer8) i4; |
| |
break; |
| |
|
| |
case 8: |
| |
(*((integer8 *) (*s_objet).objet)) = |
| |
(integer8) i8; |
| |
break; |
| |
} |
| } |
} |
| |
|
| break; |
break; |
|
Line 4878 lecture_fichier_non_formate(struct_proce
|
Line 5534 lecture_fichier_non_formate(struct_proce
|
| for(i = 0; i < (signed) deplacement; i++) |
for(i = 0; i < (signed) deplacement; i++) |
| { |
{ |
| eq4.i4 |= ((integer4) octets[i]) << |
eq4.i4 |= ((integer4) octets[i]) << |
| (8 * ((deplacement - 1) - i)); |
(8 * ((((signed) deplacement) - 1) - i)); |
| } |
} |
| |
|
| (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4; |
(*((real8 *) (*s_objet).objet)) = (real8) eq4.r4; |
|
Line 4896 lecture_fichier_non_formate(struct_proce
|
Line 5552 lecture_fichier_non_formate(struct_proce
|
| for(i = 0; i < (signed) deplacement; i++) |
for(i = 0; i < (signed) deplacement; i++) |
| { |
{ |
| eq8.i8 |= ((integer8) octets[i]) << |
eq8.i8 |= ((integer8) octets[i]) << |
| (8 * ((deplacement - 1) - i)); |
(8 * ((((signed) deplacement) - 1) - i)); |
| } |
} |
| |
|
| (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8; |
(*((real8 *) (*s_objet).objet)) = (real8) eq8.r8; |
|
Line 4989 lecture_fichier_non_formate(struct_proce
|
Line 5645 lecture_fichier_non_formate(struct_proce
|
| for(i = 0; i < (signed) deplacement; i++) |
for(i = 0; i < (signed) deplacement; i++) |
| { |
{ |
| eq4.i4 |= ((integer4) octets[i]) << |
eq4.i4 |= ((integer4) octets[i]) << |
| (8 * ((deplacement - 1) - i)); |
(8 * ((((signed) deplacement) - 1) |
| |
- i)); |
| } |
} |
| |
|
| if (j == 0) |
if (j == 0) |
|
Line 5016 lecture_fichier_non_formate(struct_proce
|
Line 5673 lecture_fichier_non_formate(struct_proce
|
| for(i = 0; i < (signed) deplacement; i++) |
for(i = 0; i < (signed) deplacement; i++) |
| { |
{ |
| eq8.i8 |= ((integer8) octets[i]) << |
eq8.i8 |= ((integer8) octets[i]) << |
| (8 * ((deplacement - 1) - i)); |
(8 * ((((signed) deplacement) - 1) |
| |
- i)); |
| } |
} |
| |
|
| if (j == 0) |
if (j == 0) |
|
Line 5046 lecture_fichier_non_formate(struct_proce
|
Line 5704 lecture_fichier_non_formate(struct_proce
|
| } |
} |
| |
|
| case 0x40: // Liste |
case 0x40: // Liste |
| |
case 0x60: // Expression |
| |
case 0x70: // Expression algébrique |
| { |
{ |
| if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits |
if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits |
| { |
{ |
|
Line 5230 lecture_fichier_non_formate(struct_proce
|
Line 5890 lecture_fichier_non_formate(struct_proce
|
| } |
} |
| } |
} |
| |
|
| if ((s_objet = allocation(s_etat_processus, LST)) == NULL) |
if (type_objet == 0x40) |
| { |
{ |
| return(NULL); |
if ((s_objet = allocation(s_etat_processus, LST)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
} |
| |
else if (type_objet == 0x60) |
| |
{ |
| |
if ((s_objet = allocation(s_etat_processus, RPN)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((s_objet = allocation(s_etat_processus, ALG)) == NULL) |
| |
{ |
| |
return(NULL); |
| |
} |
| } |
} |
| |
|
| l_element_courant = NULL; |
l_element_courant = NULL; |
|
Line 5481 lecture_fichier_non_formate(struct_proce
|
Line 6158 lecture_fichier_non_formate(struct_proce
|
| |
|
| if (longueur_buffer < 0) |
if (longueur_buffer < 0) |
| { |
{ |
| if ((flux = malloc(longueur * sizeof(unsigned char))) == NULL) |
if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char))) |
| |
== NULL) |
| { |
{ |
| (*s_etat_processus).erreur_systeme = |
(*s_etat_processus).erreur_systeme = |
| d_es_allocation_memoire; |
d_es_allocation_memoire; |
|
Line 5489 lecture_fichier_non_formate(struct_proce
|
Line 6167 lecture_fichier_non_formate(struct_proce
|
| } |
} |
| |
|
| if (fread(flux, (size_t) sizeof(unsigned char), |
if (fread(flux, (size_t) sizeof(unsigned char), |
| longueur, fichier) != (size_t) longueur) |
(size_t) longueur, fichier) != (size_t) longueur) |
| { |
{ |
| if (feof(fichier)) |
if (feof(fichier)) |
| { |
{ |
|
Line 5542 lecture_fichier_non_formate(struct_proce
|
Line 6220 lecture_fichier_non_formate(struct_proce
|
| break; |
break; |
| } |
} |
| |
|
| |
case 0x50: // Nom |
| |
{ |
| |
if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits |
| |
{ |
| |
longueur = (octets[0] & 0x07); |
| |
} |
| |
else |
| |
{ |
| |
switch(octets[0] & 0x07) |
| |
{ |
| |
case 0x00: // Longueur sur 8 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
1, fichier) != 1) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 1) |
| |
{ |
| |
octets[0] = *ptr++; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = octets[0]; |
| |
break; |
| |
} |
| |
|
| |
case 0x01: // Longueur sur 16 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
2, fichier) != 2) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 2) |
| |
{ |
| |
for(j = 0; j < 2; octets[j++] = *ptr++); |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = (((integer8) (octets[0])) << 8) |
| |
| ((integer8) (octets[1])); |
| |
break; |
| |
} |
| |
|
| |
case 0x02: // Longueur sur 32 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
4, fichier) != 4) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 4) |
| |
{ |
| |
for(j = 0; j < 4; octets[j++] = *ptr++); |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = (((integer8) (octets[0])) << 24) |
| |
| (((integer8) (octets[1])) << 16) |
| |
| (((integer8) (octets[2])) << 8) |
| |
| ((integer8) (octets[3])); |
| |
break; |
| |
} |
| |
|
| |
case 0x03: // Longueur sur 64 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
8, fichier) != 8) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 8) |
| |
{ |
| |
for(j = 0; j < 8; octets[j++] = *ptr++); |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = (((integer8) (octets[0])) << 56) |
| |
| (((integer8) (octets[1])) << 48) |
| |
| (((integer8) (octets[2])) << 40) |
| |
| (((integer8) (octets[3])) << 32) |
| |
| (((integer8) (octets[4])) << 24) |
| |
| (((integer8) (octets[5])) << 16) |
| |
| (((integer8) (octets[6])) << 8) |
| |
| ((integer8) (octets[7])); |
| |
break; |
| |
} |
| |
|
| |
default: |
| |
{ |
| |
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if ((s_objet = allocation(s_etat_processus, NOM)) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
if (((*((struct_nom *) (*s_objet).objet)).nom = |
| |
malloc((((size_t) longueur) + 1) * sizeof(unsigned char))) |
| |
== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread((unsigned char *) (*((struct_nom *) (*s_objet) |
| |
.objet)).nom, (size_t) sizeof(unsigned char), |
| |
(size_t) longueur, fichier) != (unsigned) longueur) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
liberation(s_etat_processus, s_objet); |
| |
return(NULL); |
| |
} |
| |
|
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
1, fichier) != 1) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
liberation(s_etat_processus, s_objet); |
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= (longueur + 1)) |
| |
{ |
| |
for(j = 0; j < longueur; (*((struct_nom *) |
| |
(*s_objet).objet)).nom[j] = *ptr++); |
| |
octets[0] = *ptr++; |
| |
} |
| |
else |
| |
{ |
| |
liberation(s_etat_processus, s_objet); |
| |
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
(*((struct_nom *) (*s_objet).objet)).nom[longueur] = |
| |
d_code_fin_chaine; |
| |
(*((struct_nom *) (*s_objet).objet)).symbole = |
| |
(octets[0] == 0xFF) ? d_vrai : d_faux; |
| |
break; |
| |
} |
| |
|
| |
case 0xE0: // Fonction |
| |
{ |
| |
if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits |
| |
{ |
| |
longueur = (octets[0] & 0x07); |
| |
} |
| |
else |
| |
{ |
| |
switch(octets[0] & 0x07) |
| |
{ |
| |
case 0x00: // Longueur sur 8 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
1, fichier) != 1) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 1) |
| |
{ |
| |
octets[0] = *ptr++; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = octets[0]; |
| |
break; |
| |
} |
| |
|
| |
case 0x01: // Longueur sur 16 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
2, fichier) != 2) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 2) |
| |
{ |
| |
for(j = 0; j < 2; octets[j++] = *ptr++); |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = (((integer8) (octets[0])) << 8) |
| |
| ((integer8) (octets[1])); |
| |
break; |
| |
} |
| |
|
| |
case 0x02: // Longueur sur 32 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
4, fichier) != 4) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 4) |
| |
{ |
| |
for(j = 0; j < 4; octets[j++] = *ptr++); |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = (((integer8) (octets[0])) << 24) |
| |
| (((integer8) (octets[1])) << 16) |
| |
| (((integer8) (octets[2])) << 8) |
| |
| ((integer8) (octets[3])); |
| |
break; |
| |
} |
| |
|
| |
case 0x03: // Longueur sur 64 bits |
| |
{ |
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
8, fichier) != 8) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= 8) |
| |
{ |
| |
for(j = 0; j < 8; octets[j++] = *ptr++); |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
longueur = (((integer8) (octets[0])) << 56) |
| |
| (((integer8) (octets[1])) << 48) |
| |
| (((integer8) (octets[2])) << 40) |
| |
| (((integer8) (octets[3])) << 32) |
| |
| (((integer8) (octets[4])) << 24) |
| |
| (((integer8) (octets[5])) << 16) |
| |
| (((integer8) (octets[6])) << 8) |
| |
| ((integer8) (octets[7])); |
| |
break; |
| |
} |
| |
|
| |
default: |
| |
{ |
| |
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
} |
| |
|
| |
if ((s_objet = allocation(s_etat_processus, FCT)) == NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction = |
| |
malloc((((size_t) longueur) + 1) * sizeof(unsigned char))) |
| |
== NULL) |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
| |
return(NULL); |
| |
} |
| |
|
| |
if (longueur_buffer < 0) |
| |
{ |
| |
if (fread((unsigned char *) (*((struct_fonction *) (*s_objet) |
| |
.objet)).nom_fonction, (size_t) sizeof(unsigned char), |
| |
(size_t) longueur, fichier) != (unsigned) longueur) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
liberation(s_etat_processus, s_objet); |
| |
return(NULL); |
| |
} |
| |
|
| |
if (fread(octets, (size_t) sizeof(unsigned char), |
| |
8, fichier) != 8) |
| |
{ |
| |
if (feof(fichier)) |
| |
{ |
| |
(*s_etat_processus).erreur_execution = |
| |
d_ex_syntaxe; |
| |
} |
| |
else |
| |
{ |
| |
(*s_etat_processus).erreur_systeme = |
| |
d_es_erreur_fichier; |
| |
} |
| |
|
| |
liberation(s_etat_processus, s_objet); |
| |
return(NULL); |
| |
} |
| |
} |
| |
else |
| |
{ |
| |
if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8)) |
| |
{ |
| |
for(j = 0; j < longueur; (*((struct_fonction *) |
| |
(*s_objet).objet)).nom_fonction[j] = *ptr++); |
| |
for(j = 0; j < 8; octets[j++] = *ptr++); |
| |
} |
| |
else |
| |
{ |
| |
liberation(s_etat_processus, s_objet); |
| |
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
| |
return(NULL); |
| |
} |
| |
} |
| |
|
| |
(*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] = |
| |
d_code_fin_chaine; |
| |
(*((struct_fonction *) (*s_objet).objet)).nombre_arguments = |
| |
(((integer8) (octets[0])) << 56) |
| |
| (((integer8) (octets[1])) << 48) |
| |
| (((integer8) (octets[2])) << 40) |
| |
| (((integer8) (octets[3])) << 32) |
| |
| (((integer8) (octets[4])) << 24) |
| |
| (((integer8) (octets[5])) << 16) |
| |
| (((integer8) (octets[6])) << 8) |
| |
| ((integer8) (octets[7])); |
| |
break; |
| |
} |
| |
|
| default: |
default: |
| { |
{ |
| (*s_etat_processus).erreur_execution = d_ex_syntaxe; |
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
Line 5572 lecture_fichier_non_formate(struct_proce
|
Line 6779 lecture_fichier_non_formate(struct_proce
|
| |
|
| if ((octets[0] & 0x01) != 0) |
if ((octets[0] & 0x01) != 0) |
| { |
{ |
| deplacement = ((octets[0] & 0x0F) >> 1) + 1; |
deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1); |
| |
|
| if (fread(octets, (size_t) sizeof(unsigned char), deplacement, |
if (fread(octets, (size_t) sizeof(unsigned char), deplacement, |
| fichier) != deplacement) |
fichier) != deplacement) |
|
Line 5593 lecture_fichier_non_formate(struct_proce
|
Line 6800 lecture_fichier_non_formate(struct_proce
|
| } |
} |
| } |
} |
| |
|
| |
if (longueur_buffer >= 0) |
| |
{ |
| |
(*((unsigned char **) argument)) = ptr; |
| |
} |
| |
|
| return(s_objet); |
return(s_objet); |
| } |
} |
| |
|
![[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