version 1.11, 2010/05/24 10:58:30
|
version 1.45, 2012/08/22 10:47:14
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.0.16 |
RPL/2 (R) version 4.1.10 |
Copyright (C) 1989-2010 Dr. BERTRAND Joël |
Copyright (C) 1989-2012 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 20
|
Line 20
|
*/ |
*/ |
|
|
|
|
#include "rpl.conv.h" |
#include "rpl-conv.h" |
|
|
|
|
/* |
/* |
Line 30
|
Line 30
|
Entrées : structure sur l'état du processus et objet à afficher |
Entrées : structure sur l'état du processus et objet à afficher |
Longueur est la précision requise et longueur_champ, le nombre maximal |
Longueur est la précision requise et longueur_champ, le nombre maximal |
de caractères de la chaîne résultat (-1 signifiant une absence de contrainte) |
de caractères de la chaîne résultat (-1 signifiant une absence de contrainte) |
Type = 'F/U' |
Type = 'F/U' (formaté, non formaté) |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Sorties : chaine de caractères et longueur du tableau de caractères |
Sorties : chaine de caractères et longueur du tableau de caractères |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 75 formateur_fichier(struct_processus *s_et
|
Line 75 formateur_fichier(struct_processus *s_et
|
|
|
logical1 autorisation_parenthese; |
logical1 autorisation_parenthese; |
logical1 format_degenere; |
logical1 format_degenere; |
logical1 longueur_3bits; |
|
logical1 longueur_6bits; |
|
logical1 presence_signe; |
logical1 presence_signe; |
|
|
struct_liste_chainee *l_atome; |
struct_liste_chainee *l_atome; |
Line 97 formateur_fichier(struct_processus *s_et
|
Line 95 formateur_fichier(struct_processus *s_et
|
unsigned char *chaine_tampon; |
unsigned char *chaine_tampon; |
unsigned char *chaine_sauvegarde; |
unsigned char *chaine_sauvegarde; |
unsigned char *format_chaine; |
unsigned char *format_chaine; |
unsigned char longueur_optimale; |
|
unsigned char parametre_longueur; |
|
unsigned char *ptre; |
unsigned char *ptre; |
unsigned char *ptrl; |
unsigned char *ptrl; |
unsigned char tampon[64 + 1]; |
unsigned char tampon[64 + 1]; |
|
|
unsigned long i; |
unsigned long i; |
unsigned long j; |
unsigned long j; |
unsigned long longueur_binaire; |
|
unsigned long longueur_champ_final; |
|
unsigned long nombre_arguments; |
unsigned long nombre_arguments; |
unsigned long nombre_arguments_fonction; |
unsigned long nombre_arguments_fonction; |
unsigned long nombre_colonnes; |
unsigned long nombre_colonnes; |
Line 114 formateur_fichier(struct_processus *s_et
|
Line 108 formateur_fichier(struct_processus *s_et
|
unsigned long nombre_lignes; |
unsigned long nombre_lignes; |
|
|
integer8 longueur_liste; |
integer8 longueur_liste; |
integer8 longueur_entete; |
|
integer8 longueur_objet; |
|
integer8 longueur_totale; |
integer8 longueur_totale; |
integer8 masque_binaire; |
integer8 masque_binaire; |
integer8 position_1; |
integer8 position_1; |
integer8 position_2; |
integer8 position_2; |
integer8 position_3; |
integer8 position_3; |
|
|
long offset; |
|
|
|
(*recursivite)++; |
(*recursivite)++; |
|
|
if (type == 'F') |
if (type == 'F') |
Line 138 formateur_fichier(struct_processus *s_et
|
Line 128 formateur_fichier(struct_processus *s_et
|
|
|
strcpy(base, " "); |
strcpy(base, " "); |
|
|
longueur_binaire = 0; |
|
masque_binaire = 0; |
masque_binaire = 0; |
|
|
if ((*s_objet).type == ALG) |
if ((*s_objet).type == ALG) |
Line 998 formateur_fichier(struct_processus *s_et
|
Line 987 formateur_fichier(struct_processus *s_et
|
return(NULL); |
return(NULL); |
} |
} |
|
|
longueur_binaire = longueur_entiers_binaires(s_etat_processus); |
|
masque_binaire = masque_entiers_binaires(s_etat_processus); |
masque_binaire = masque_entiers_binaires(s_etat_processus); |
|
|
if ((test_cfsf(s_etat_processus, 43) == d_faux) && |
if ((test_cfsf(s_etat_processus, 43) == d_faux) && |
Line 1176 formateur_fichier(struct_processus *s_et
|
Line 1164 formateur_fichier(struct_processus *s_et
|
return(NULL); |
return(NULL); |
} |
} |
|
|
if ((longueur_champ == -1) || (strlen((unsigned char *) |
if ((longueur_champ == -1) || (((long) strlen((unsigned char *) |
(*s_objet).objet) < longueur_champ)) |
(*s_objet).objet)) < longueur_champ)) |
{ |
{ |
chaine = (unsigned char *) malloc((strlen((unsigned char *) |
chaine = (unsigned char *) malloc((strlen((unsigned char *) |
((*s_objet).objet)) + 1) * sizeof(unsigned char)); |
((*s_objet).objet)) + 1) * sizeof(unsigned char)); |
Line 1508 formateur_fichier(struct_processus *s_et
|
Line 1496 formateur_fichier(struct_processus *s_et
|
return(NULL); |
return(NULL); |
} |
} |
|
|
position_3 = strlen(format_chaine); |
position_3 = strlen(format_chaine) - 1; |
format_chaine[--position_3] = d_code_fin_chaine; |
|
|
if (format_chaine[position_3] != ')') |
|
{ |
|
free(chaine); |
|
free(format_chaine); |
|
|
|
(*s_etat_processus).erreur_execution = |
|
d_ex_erreur_format_fichier; |
|
return(NULL); |
|
} |
|
|
|
format_chaine[position_3] = d_code_fin_chaine; |
|
|
position_2 = position_1; |
position_2 = position_1; |
|
|
Line 1728 formateur_fichier(struct_processus *s_et
|
Line 1727 formateur_fichier(struct_processus *s_et
|
(((*(*((struct_tableau *) (*s_format).objet)) |
(((*(*((struct_tableau *) (*s_format).objet)) |
.elements[i]).type == TBL) && |
.elements[i]).type == TBL) && |
((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) |
((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) |
.type == TAB))) |
.type == TBL))) |
{ |
{ |
chaine_sauvegarde = chaine; |
chaine_sauvegarde = chaine; |
|
|
Line 2711 formateur_fichier(struct_processus *s_et
|
Line 2710 formateur_fichier(struct_processus *s_et
|
*/ |
*/ |
|
|
#define __zone() \ |
#define __zone() \ |
do { int _i; for(_i = 0; _i < longueur_totale; _i++) \ |
do { int _i; \ |
printf("%02X ", chaine[_i]); printf("\b\n"); } while(0) |
for(_i = 0; _i < longueur_totale; _i++) \ |
|
printf("%02X ", chaine[_i]); printf("\b\n"); } while(0) |
|
|
/* |
/* |
* Chaque enregistrement est composé d'une donnée (une liste) |
* Chaque enregistrement est composé d'une donnée (une liste) |
Line 2730 formateur_fichier(struct_processus *s_et
|
Line 2730 formateur_fichier(struct_processus *s_et
|
* Longueur : (pour l'instruction backspace) |
* Longueur : (pour l'instruction backspace) |
* |
* |
* 00 XXXXXX longueur sur 6 bits |
* 00 XXXXXX longueur sur 6 bits |
* 01 ------ longueur sur 16 bits |
* 01 XXXXXX longueur sur 16 bits |
* 10 ------ longueur sur 32 bits |
* 10 XXXXXX longueur sur 32 bits |
* 11 ------ longueur sur 64 bits |
* 11 XXXXXX longueur sur 64 bits |
|
* |
|
* Exemples : |
|
* [00 XXXXXX] |
|
* [01 ----XX][XXXXXXXX][01 XXXXXX] |
|
* [10 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][10 XXXXXX] |
|
* [11 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX] |
|
* [XXXXXXXX][XXXXXXXX][11 XXXXXX] |
* |
* |
* Structures des enregistrements : |
* Structures des enregistrements : |
* chaque type de donnée est associé à une en-tête binaire comprenant |
* chaque type de donnée est associé à une en-tête binaire comprenant |
Line 2813 formateur_fichier(struct_processus *s_et
|
Line 2820 formateur_fichier(struct_processus *s_et
|
* 1001 10 10 table de longueur integer*4 |
* 1001 10 10 table de longueur integer*4 |
* 1001 10 11 table de longueur integer*8 |
* 1001 10 11 table de longueur integer*8 |
* |
* |
|
* 1010 00 10 vecteur real*4 (dimensions integer*1) |
|
* 1010 01 10 vecteur real*4 (dimensions integer*2) |
|
* 1010 10 10 vecteur real*4 (dimensions integer*4) |
|
* 1010 11 10 vecteur real*4 (dimensions integer*8) |
|
* 1010 00 11 vecteur real*8 (dimensions integer*1) |
|
* 1010 01 11 vecteur real*8 (dimensions integer*2) |
|
* 1010 10 11 vecteur real*8 (dimensions integer*4) |
|
* 1010 11 11 vecteur real*8 (dimensions integer*8) |
|
* 1011 00 10 vecteur complex*8 (dimensions integer*1) |
|
* 1011 01 10 vecteur complex*8 (dimensions integer*2) |
|
* 1011 10 10 vecteur complex*8 (dimensions integer*4) |
|
* 1011 11 10 vecteur complex*8 (dimensions integer*8) |
|
* 1011 00 11 vecteur complex*16 (dimensions integer*1) |
|
* 1011 01 11 vecteur complex*16 (dimensions integer*2) |
|
* 1011 10 11 vecteur complex*16 (dimensions integer*4) |
|
* 1011 11 11 vecteur complex*16 (dimensions integer*8) |
|
* |
|
* 1100 00 10 matrice real*4 (dimensions integer*1) |
|
* 1100 01 10 matrice real*4 (dimensions integer*2) |
|
* 1100 10 10 matrice real*4 (dimensions integer*4) |
|
* 1100 11 10 matrice real*4 (dimensions integer*8) |
|
* 1100 00 11 matrice real*8 (dimensions integer*1) |
|
* 1100 01 11 matrice real*8 (dimensions integer*2) |
|
* 1100 10 11 matrice real*8 (dimensions integer*4) |
|
* 1100 11 11 matrice real*8 (dimensions integer*8) |
|
* 1101 00 10 matrice complex*8 (dimensions integer*1) |
|
* 1101 01 10 matrice complex*8 (dimensions integer*2) |
|
* 1101 10 10 matrice complex*8 (dimensions integer*4) |
|
* 1101 11 10 matrice complex*8 (dimensions integer*8) |
|
* 1101 00 11 matrice complex*16 (dimensions integer*1) |
|
* 1101 01 11 matrice complex*16 (dimensions integer*2) |
|
* 1101 10 11 matrice complex*16 (dimensions integer*4) |
|
* 1101 11 11 matrice complex*16 (dimensions integer*8) |
|
* |
* Les longueurs indiquées par le champ LL suivent l'en-tête : |
* Les longueurs indiquées par le champ LL suivent l'en-tête : |
|
* 00 : integer*1 |
|
* 01 : integer*2 |
|
* 10 : integer*4 |
|
* 11 : integer*8 |
|
* |
* [En-tête][longueur_1][longueur_2][données] |
* [En-tête][longueur_1][longueur_2][données] |
* le nombre de champs longueur dépendant des types d'enregistrement. |
* le nombre de champs longueur dépendant des types d'enregistrement. |
* |
* |
Line 2826 formateur_fichier(struct_processus *s_et
|
Line 2872 formateur_fichier(struct_processus *s_et
|
|
|
strcpy(base, " "); |
strcpy(base, " "); |
|
|
longueur_binaire = 0; |
|
masque_binaire = 0; |
masque_binaire = 0; |
|
|
if ((*s_objet).type == ALG) |
if ((*s_objet).type == ALG) |
Line 3686 formateur_fichier(struct_processus *s_et
|
Line 3731 formateur_fichier(struct_processus *s_et
|
return(NULL); |
return(NULL); |
} |
} |
|
|
longueur_binaire = longueur_entiers_binaires(s_etat_processus); |
|
masque_binaire = masque_entiers_binaires(s_etat_processus); |
masque_binaire = masque_entiers_binaires(s_etat_processus); |
|
|
if ((test_cfsf(s_etat_processus, 43) == d_faux) && |
if ((test_cfsf(s_etat_processus, 43) == d_faux) && |
Line 3884 formateur_fichier(struct_processus *s_et
|
Line 3928 formateur_fichier(struct_processus *s_et
|
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
*/ |
*/ |
|
|
if ((format_sortie != 'S') && (format_sortie != 'F') && |
if (format_sortie != 'C') |
(format_sortie != 'I') && (format_sortie != 'E')) |
|
{ |
{ |
(*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
return(NULL); |
return(NULL); |
} |
} |
|
|
if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, |
if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus, |
(void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C', |
(*s_objet).objet, 'C', longueur, longueur_effective)) |
longueur, longueur_champ, format_sortie)) == NULL) |
== NULL) |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine = (unsigned char *) malloc((strlen(chaine_formatee) |
|
+ 1) * sizeof(unsigned char)); |
|
|
|
if (chaine == NULL) |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
return(NULL); |
} |
} |
|
|
strcpy(chaine, chaine_formatee); |
|
free(chaine_formatee); |
|
} |
} |
else if ((*s_objet).type == RPN) |
else if ((*s_objet).type == RPN) |
{ |
{ |
Line 4009 formateur_fichier(struct_processus *s_et
|
Line 4039 formateur_fichier(struct_processus *s_et
|
return(NULL); |
return(NULL); |
} |
} |
|
|
switch(longueur) |
if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus, |
|
(*s_objet).objet, 'I', longueur, longueur_effective)) |
|
== NULL) |
{ |
{ |
case 1: |
return(NULL); |
{ |
|
if ((*((integer8 *) (*s_objet).objet)) != |
|
((integer1) (*((integer8 *) (*s_objet).objet)))) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
longueur_totale = 2; |
|
chaine[0] = 0x10; |
|
chaine[1] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
break; |
|
} |
|
|
|
case 2: |
|
{ |
|
if ((*((integer8 *) (*s_objet).objet)) != |
|
((integer2) (*((integer8 *) (*s_objet).objet)))) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
longueur_totale = 3; |
|
chaine[0] = 0x11; |
|
chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 8) |
|
& 0xFF; |
|
chaine[2] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
break; |
|
} |
|
|
|
case 4: |
|
{ |
|
if ((*((integer4 *) (*s_objet).objet)) != |
|
((integer2) (*((integer8 *) (*s_objet).objet)))) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
longueur_totale = 5; |
|
chaine[0] = 0x12; |
|
chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 24) |
|
& 0xFF; |
|
chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 16) |
|
& 0xFF; |
|
chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 8) |
|
& 0xFF; |
|
chaine[4] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
break; |
|
} |
|
|
|
case 8: |
|
{ |
|
if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
longueur_totale = 9; |
|
chaine[0] = 0x13; |
|
chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 56) |
|
& 0xFF; |
|
chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 48) |
|
& 0xFF; |
|
chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 40) |
|
& 0xFF; |
|
chaine[4] = ((*((integer8 *) (*s_objet).objet)) >> 32) |
|
& 0xFF; |
|
chaine[5] = ((*((integer8 *) (*s_objet).objet)) >> 24) |
|
& 0xFF; |
|
chaine[6] = ((*((integer8 *) (*s_objet).objet)) >> 16) |
|
& 0xFF; |
|
chaine[7] = ((*((integer8 *) (*s_objet).objet)) >> 8) |
|
& 0xFF; |
|
chaine[8] = (*((integer8 *) (*s_objet).objet)) & 0xFF; |
|
break; |
|
} |
|
|
|
default : |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_erreur_format_fichier; |
|
return(NULL); |
|
} |
|
} |
} |
|
|
(*longueur_effective) = longueur_totale; |
|
} |
} |
else if ((*s_objet).type == FCT) |
else if ((*s_objet).type == FCT) |
{ |
{ |
Line 4596 formateur_fichier(struct_processus *s_et
|
Line 4515 formateur_fichier(struct_processus *s_et
|
(((*(*((struct_tableau *) (*s_format).objet)) |
(((*(*((struct_tableau *) (*s_format).objet)) |
.elements[i]).type == TBL) && |
.elements[i]).type == TBL) && |
((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) |
((*(*((struct_tableau *) (*s_objet).objet)).elements[i]) |
.type == TAB))) |
.type == TBL))) |
{ |
{ |
chaine_sauvegarde = chaine; |
chaine_sauvegarde = chaine; |
|
|
Line 5306 formateur_fichier(struct_processus *s_et
|
Line 5225 formateur_fichier(struct_processus *s_et
|
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
*/ |
*/ |
|
|
if ((format_sortie != 'S') && (format_sortie != 'F') && |
if (format_sortie != 'R') |
(format_sortie != 'I') && (format_sortie != 'E')) |
|
{ |
{ |
(*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
d_ex_erreur_format_fichier; |
d_ex_erreur_format_fichier; |
return(NULL); |
return(NULL); |
} |
} |
|
|
if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus, |
if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus, |
(void *) ((real8 *) ((*s_objet).objet)), 'R', |
(*s_objet).objet, 'R', longueur, longueur_effective)) |
longueur, longueur_champ, format_sortie)) == NULL) |
== NULL) |
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1) |
|
* sizeof(unsigned char)); |
|
|
|
if (chaine == NULL) |
|
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
return(NULL); |
} |
} |
|
|
strcpy(chaine, chaine_formatee); |
|
free(chaine_formatee); |
|
} |
} |
else if ((*s_objet).type == VCX) |
else if ((*s_objet).type == VCX) |
{ |
{ |
Line 5733 formateur_fichier_nombre(struct_processu
|
Line 5638 formateur_fichier_nombre(struct_processu
|
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Recherche de la longueur de l'entier minimale pour représenter la donnée |
|
-------------------------------------------------------------------------------- |
|
*/ |
|
|
|
unsigned char |
|
recherche_longueur_optimale(integer8 parametre) |
|
{ |
|
if (parametre == (integer8) ((integer1) parametre)) |
|
{ |
|
return(0x0); |
|
} |
|
else if (parametre == (integer8) ((integer2) parametre)) |
|
{ |
|
return(0x1); |
|
} |
|
else if (parametre == (integer8) ((integer4) parametre)) |
|
{ |
|
return(0x2); |
|
} |
|
else |
|
{ |
|
return(0x3); |
|
} |
|
} |
|
|
|
|
|
/* |
|
-------------------------------------------------------------------------------- |
|
Formateur des réels et entiers |
Formateur des réels et entiers |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
*/ |
*/ |
Line 5983 formateur_fichier_reel(struct_processus
|
Line 5860 formateur_fichier_reel(struct_processus
|
|
|
return(chaine); |
return(chaine); |
} |
} |
|
|
|
|
|
/* |
|
-------------------------------------------------------------------------------- |
|
Mêmes fonctions mais pour les fichiers binaires |
|
-------------------------------------------------------------------------------- |
|
*/ |
|
|
|
unsigned char * |
|
formateur_fichier_binaire_nombre(struct_processus *s_etat_processus, |
|
void *valeur_numerique, unsigned char type, long longueur, |
|
long *longueur_conversion) |
|
{ |
|
unsigned char *chaine; |
|
|
|
switch(type) |
|
{ |
|
default : |
|
case 'I' : |
|
{ |
|
switch(longueur) |
|
{ |
|
case 1: |
|
{ |
|
if ((*((integer8 *) valeur_numerique)) != |
|
((integer1) (*((integer8 *) valeur_numerique)))) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
(*longueur_conversion) = 2; |
|
chaine[0] = 0x10; |
|
chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF; |
|
break; |
|
} |
|
|
|
case 2: |
|
{ |
|
if ((*((integer8 *) valeur_numerique)) != |
|
((integer2) (*((integer8 *) valeur_numerique)))) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
(*longueur_conversion) = 3; |
|
chaine[0] = 0x11; |
|
chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8) |
|
& 0xFF; |
|
chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF; |
|
break; |
|
} |
|
|
|
case 4: |
|
{ |
|
if ((*((integer8 *) valeur_numerique)) != |
|
((integer2) (*((integer8 *) valeur_numerique)))) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
(*longueur_conversion) = 5; |
|
chaine[0] = 0x12; |
|
chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24) |
|
& 0xFF; |
|
chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16) |
|
& 0xFF; |
|
chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8) |
|
& 0xFF; |
|
chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF; |
|
break; |
|
} |
|
|
|
case 8: |
|
{ |
|
if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
(*longueur_conversion) = 9; |
|
chaine[0] = 0x13; |
|
chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56) |
|
& 0xFF; |
|
chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48) |
|
& 0xFF; |
|
chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40) |
|
& 0xFF; |
|
chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32) |
|
& 0xFF; |
|
chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24) |
|
& 0xFF; |
|
chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16) |
|
& 0xFF; |
|
chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8) |
|
& 0xFF; |
|
chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF; |
|
break; |
|
} |
|
|
|
default : |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_erreur_format_fichier; |
|
return(NULL); |
|
} |
|
} |
|
|
|
break; |
|
} |
|
|
|
case 'R' : |
|
{ |
|
switch(longueur) |
|
{ |
|
case 4: |
|
{ |
|
double vinf; |
|
double vsup; |
|
|
|
union |
|
{ |
|
real4 r4; |
|
integer4 i4; |
|
} eq4; |
|
|
|
if ((*((real8 *) valeur_numerique)) > 0) |
|
{ |
|
vinf = nextafter((*((real8 *) valeur_numerique)), 0); |
|
vsup = nextafter((*((real8 *) valeur_numerique)), |
|
(*((real8 *) valeur_numerique)) * 2); |
|
} |
|
else |
|
{ |
|
vinf = nextafter((*((real8 *) valeur_numerique)), |
|
(*((real8 *) valeur_numerique)) * 2); |
|
vsup = nextafter((*((real8 *) valeur_numerique)), 0); |
|
} |
|
|
|
if (!((vinf <= ((real4) (*((real8 *) valeur_numerique)))) && |
|
((real4) ((*((real8 *) valeur_numerique))) |
|
<= vsup))) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
eq4.r4 = (real4) (*((real8 *) valeur_numerique)); |
|
(*longueur_conversion) = 5; |
|
chaine[0] = 0x12; |
|
chaine[1] = (eq4.i4 >> 24) & 0xFF; |
|
chaine[2] = (eq4.i4 >> 16) & 0xFF; |
|
chaine[3] = (eq4.i4 >> 8) & 0xFF; |
|
chaine[4] = eq4.i4 & 0xFF; |
|
break; |
|
} |
|
|
|
case 8: |
|
{ |
|
union |
|
{ |
|
real8 r8; |
|
integer8 i8; |
|
} eq8; |
|
|
|
if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
eq8.r8 = (*((real8 *) valeur_numerique)); |
|
|
|
(*longueur_conversion) = 9; |
|
chaine[0] = 0x13; |
|
chaine[1] = (eq8.i8 >> 56) & 0xFF; |
|
chaine[2] = (eq8.i8 >> 48) & 0xFF; |
|
chaine[3] = (eq8.i8 >> 40) & 0xFF; |
|
chaine[4] = (eq8.i8 >> 32) & 0xFF; |
|
chaine[5] = (eq8.i8 >> 24) & 0xFF; |
|
chaine[6] = (eq8.i8 >> 16) & 0xFF; |
|
chaine[7] = (eq8.i8 >> 8) & 0xFF; |
|
chaine[8] = eq8.i8 & 0xFF; |
|
break; |
|
} |
|
|
|
default : |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_erreur_format_fichier; |
|
return(NULL); |
|
} |
|
} |
|
|
|
break; |
|
} |
|
|
|
case 'C' : |
|
{ |
|
switch(longueur) |
|
{ |
|
case 8: |
|
{ |
|
unsigned char *partie_reelle; |
|
unsigned char *partie_imaginaire; |
|
|
|
long limag; |
|
long lreel; |
|
|
|
if ((partie_reelle = formateur_fichier_binaire_nombre( |
|
s_etat_processus, &((*((complex16 *) |
|
valeur_numerique)).partie_reelle), 'R', 4, &lreel)) |
|
== NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
|
if ((partie_imaginaire = formateur_fichier_binaire_nombre( |
|
s_etat_processus, &((*((complex16 *) |
|
valeur_numerique)).partie_imaginaire), 'R', 4, |
|
&limag)) == NULL) |
|
{ |
|
free(partie_reelle); |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc((lreel + limag - 1) * |
|
sizeof(unsigned char))) == NULL) |
|
{ |
|
free(partie_reelle); |
|
free(partie_imaginaire); |
|
|
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = 0x18; |
|
memcpy(chaine + 1, partie_reelle + 1, lreel - 1); |
|
memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1); |
|
(*longueur_conversion) = lreel + limag - 1; |
|
|
|
free(partie_reelle); |
|
free(partie_imaginaire); |
|
break; |
|
} |
|
|
|
case 16: |
|
{ |
|
unsigned char *partie_reelle; |
|
unsigned char *partie_imaginaire; |
|
|
|
long limag; |
|
long lreel; |
|
|
|
if ((partie_reelle = formateur_fichier_binaire_nombre( |
|
s_etat_processus, &((*((complex16 *) |
|
valeur_numerique)).partie_reelle), 'R', 8, &lreel)) |
|
== NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
|
if ((partie_imaginaire = formateur_fichier_binaire_nombre( |
|
s_etat_processus, &((*((complex16 *) |
|
valeur_numerique)).partie_imaginaire), 'R', 8, |
|
&limag)) == NULL) |
|
{ |
|
free(partie_reelle); |
|
return(NULL); |
|
} |
|
|
|
if ((chaine = malloc((lreel + limag - 1) * |
|
sizeof(unsigned char))) == NULL) |
|
{ |
|
free(partie_reelle); |
|
free(partie_imaginaire); |
|
|
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = 0x19; |
|
memcpy(chaine + 1, partie_reelle + 1, lreel - 1); |
|
memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1); |
|
(*longueur_conversion) = lreel + limag - 1; |
|
|
|
free(partie_reelle); |
|
free(partie_imaginaire); |
|
break; |
|
} |
|
|
|
default : |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_erreur_format_fichier; |
|
return(NULL); |
|
} |
|
} |
|
|
|
break; |
|
} |
|
} |
|
|
|
return(chaine); |
|
} |
|
|
|
// vim: ts=4 |