version 1.52, 2013/03/10 17:01:05
|
version 1.55, 2013/03/15 11:37:25
|
Line 100 formateur_fichier(struct_processus *s_et
|
Line 100 formateur_fichier(struct_processus *s_et
|
unsigned char *ptre; |
unsigned char *ptre; |
unsigned char *ptrl; |
unsigned char *ptrl; |
unsigned char tampon[64 + 1]; |
unsigned char tampon[64 + 1]; |
|
unsigned char type_binaire; |
|
|
unsigned long i; |
unsigned long i; |
unsigned long j; |
unsigned long j; |
Line 2744 formateur_fichier(struct_processus *s_et
|
Line 2745 formateur_fichier(struct_processus *s_et
|
* |
* |
* XXXXXXX0 longueur sur 7 bits |
* XXXXXXX0 longueur sur 7 bits |
* XXXX0011 XXXXXXXX XXXX0011 longueur sur 16 bits |
* XXXX0011 XXXXXXXX XXXX0011 longueur sur 16 bits |
* MSB(1/2) LSB MSB(2/2) |
* LSB(1/2) MSB LSB(2/2) |
* XXXX0101 XXXXXXXX XXXXXXXX XXXX0101 longueur sur 24 bits |
* XXXX0101 XXXXXXXX XXXXXXXX XXXX0101 longueur sur 24 bits |
* XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX |
* XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX |
* XXXX0111 longueur sur 32 bits |
* XXXX0111 longueur sur 32 bits |
Line 2888 formateur_fichier(struct_processus *s_et
|
Line 2889 formateur_fichier(struct_processus *s_et
|
chaine_formatee = NULL; |
chaine_formatee = NULL; |
chaine_sauvegarde = NULL; |
chaine_sauvegarde = NULL; |
|
|
if ((*s_objet).type == ALG) |
if ((*s_objet).type == BIN) |
{ |
{ |
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Expression algébrique |
Entier binaire en base 2, 8, 10 ou 16 |
|
Poids fort 0000 |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
*/ |
*/ |
|
|
} |
if (format_sortie != 'L') |
else if ((*s_objet).type == BIN) |
{ |
{ |
(*s_etat_processus).erreur_execution = |
|
d_ex_erreur_format_fichier; |
|
return(NULL); |
|
} |
|
|
/* |
if (longueur_champ < 8) |
-------------------------------------------------------------------------------- |
{ |
Entier binaire en base 2, 8, 10 ou 16 |
if ((*((logical8 *) (*s_objet).objet)) >= |
-------------------------------------------------------------------------------- |
((logical8) 1 << (8 * longueur_champ))) |
*/ |
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_representation; |
|
return(NULL); |
|
} |
|
} |
|
|
|
(*longueur_effective) = longueur_champ + 1; |
|
|
|
if ((chaine = malloc((*longueur_effective) * sizeof(unsigned char))) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = longueur_champ; |
|
|
|
for(i = 1; i <= (unsigned) (*longueur_effective); i++) |
|
{ |
|
chaine[i] = ((*((logical8 *) (*s_objet).objet)) >> |
|
(8 * (longueur_champ - i))) & 0xFF; |
|
} |
} |
} |
else if ((*s_objet).type == CHN) |
else if ((*s_objet).type == CHN) |
{ |
{ |
Line 3088 formateur_fichier(struct_processus *s_et
|
Line 3114 formateur_fichier(struct_processus *s_et
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else if ((*s_objet).type == RPN) |
|
{ |
|
|
|
/* |
|
-------------------------------------------------------------------------------- |
|
Définition |
|
-------------------------------------------------------------------------------- |
|
*/ |
|
} |
|
else if ((*s_objet).type == INT) |
else if ((*s_objet).type == INT) |
{ |
{ |
|
|
Line 3132 formateur_fichier(struct_processus *s_et
|
Line 3149 formateur_fichier(struct_processus *s_et
|
*/ |
*/ |
|
|
} |
} |
else if ((*s_objet).type == LST) |
else if (((*s_objet).type == LST) || ((*s_objet).type == ALG) |
|
|| ((*s_objet).type == RPN)) |
{ |
{ |
|
|
/* |
/* |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Liste |
Liste |
Poids fort 0100 |
Poids fort 0100 |
|
|
|
Expression algébrique |
|
Poids fort 0111 |
|
|
|
Définition |
|
Poids fort 0110 |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
*/ |
*/ |
|
|
Line 3150 formateur_fichier(struct_processus *s_et
|
Line 3174 formateur_fichier(struct_processus *s_et
|
return(NULL); |
return(NULL); |
} |
} |
|
|
|
if ((*s_objet).type == LST) |
|
{ |
|
type_binaire = 0x40; |
|
} |
|
else if ((*s_objet).type == RPN) |
|
{ |
|
type_binaire = 0x60; |
|
} |
|
else // ALG |
|
{ |
|
type_binaire = 0x70; |
|
} |
|
|
// Calcul de la longueur de la liste. |
// Calcul de la longueur de la liste. |
|
|
longueur_liste = 0; |
longueur_liste = 0; |
Line 3163 formateur_fichier(struct_processus *s_et
|
Line 3200 formateur_fichier(struct_processus *s_et
|
|
|
if (longueur_liste < (1LL << 3)) |
if (longueur_liste < (1LL << 3)) |
{ |
{ |
chaine[0] = 0x40 | (longueur_liste & 0x7); |
chaine[0] = type_binaire | (longueur_liste & 0x7); |
} |
} |
else if (longueur_liste < (1LL << 8)) |
else if (longueur_liste < (1LL << 8)) |
{ |
{ |
chaine[0] = 0x48; |
chaine[0] = type_binaire | 0x08; |
} |
} |
else if (longueur_liste < (1LL << 16)) |
else if (longueur_liste < (1LL << 16)) |
{ |
{ |
chaine[0] = 0x49; |
chaine[0] = type_binaire | 0x09; |
} |
} |
else if (longueur_liste < (1LL << 32)) |
else if (longueur_liste < (1LL << 32)) |
{ |
{ |
chaine[0] = 0x4A; |
chaine[0] = type_binaire | 0x0A; |
} |
} |
else |
else |
{ |
{ |
chaine[0] = 0x4B; |
chaine[0] = type_binaire | 0x0B; |
} |
} |
|
|
longueur_totale = 1; |
longueur_totale = 1; |
Line 3591 formateur_fichier(struct_processus *s_et
|
Line 3628 formateur_fichier(struct_processus *s_et
|
if ((longueur_totale < (((integer8) 1) << (8 * (i + 2)))) |
if ((longueur_totale < (((integer8) 1) << (8 * (i + 2)))) |
|| (i == 6)) |
|| (i == 6)) |
{ |
{ |
// MSB (4 bits de poids fort) |
// LSB (4 bits de poids fort) |
tampon[0] = ((longueur_totale >> 8) & 0xF0) |
tampon[0] = (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] = (longueur_totale >> (j + 1)) |
tampon[(i - j) + 1] = |
|
(longueur_totale >> (8 * (j + 1))) |
& 0xFF; |
& 0xFF; |
} |
} |
|
|
// MSB (4 bits de poids faible) |
// LSB (4 bits de poids faible) |
tampon[i + 2] = (((longueur_totale >> 8) & 0x0F) << 4) |
tampon[i + 2] = ((longueur_totale & 0x0F) << 4) |
| 0x1 /* longueur supérieure à 7 bits */ |
| 0x1 /* longueur supérieure à 7 bits */ |
| ((i + 1) << 1); |
| ((i + 1) << 1); |
break; |
break; |
Line 4093 formateur_fichier_binaire_nombre(struct_
|
Line 4131 formateur_fichier_binaire_nombre(struct_
|
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 4525 lecture_fichier_non_formate(struct_proce
|
Line 4563 lecture_fichier_non_formate(struct_proce
|
{ |
{ |
file *fichier; |
file *fichier; |
|
|
|
int j; |
|
|
integer8 i; |
integer8 i; |
integer8 longueur; |
integer8 longueur; |
|
|
Line 4535 lecture_fichier_non_formate(struct_proce
|
Line 4575 lecture_fichier_non_formate(struct_proce
|
|
|
unsigned char octets[8]; |
unsigned char octets[8]; |
unsigned char *buffer; |
unsigned char *buffer; |
|
unsigned char *flux; |
unsigned char *ptr; |
unsigned char *ptr; |
|
|
size_t deplacement; |
size_t deplacement; |
Line 4547 lecture_fichier_non_formate(struct_proce
|
Line 4588 lecture_fichier_non_formate(struct_proce
|
} |
} |
else |
else |
{ |
{ |
buffer = argument; |
buffer = (*((unsigned char **) argument)); |
ptr = buffer; |
ptr = buffer; |
fichier = NULL; |
fichier = NULL; |
} |
} |
|
|
|
|
if (longueur_buffer < 0) |
if (longueur_buffer < 0) |
{ |
{ |
if (fread(octets, (size_t) sizeof(unsigned char), |
if (fread(octets, (size_t) sizeof(unsigned char), |
1, fichier) != 1) |
1, fichier) != 1) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier; |
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else |
else |
{ |
{ |
octets[0] = *ptr++; |
if ((longueur_buffer - (ptr - buffer)) >= 1) |
|
{ |
|
octets[0] = *ptr++; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
return(NULL); |
|
} |
} |
} |
|
|
switch(octets[0] & 0xF0) |
switch(octets[0] & 0xF0) |
{ |
{ |
case 0x10: // Scalaire |
case 0x00: // Binaire |
{ |
{ |
switch(octets[0] & 0x0C) |
switch(octets[0] & 0x0F) |
{ |
{ |
case 0x00: // Entier |
case 0x01: // logical*1 |
{ |
{ |
if ((s_objet = allocation(s_etat_processus, INT)) == NULL) |
deplacement = 1; |
|
break; |
|
} |
|
|
|
case 0x02: // logical*2 |
|
{ |
|
deplacement = 2; |
|
break; |
|
} |
|
|
|
case 0x04: // logical*4 |
|
{ |
|
deplacement = 4; |
|
break; |
|
} |
|
|
|
case 0x08: // logical*8 |
|
{ |
|
deplacement = 8; |
|
break; |
|
} |
|
|
|
default: |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
if (longueur_buffer < 0) |
|
{ |
|
if (fread(octets, (size_t) sizeof(unsigned char), |
|
deplacement, fichier) != deplacement) |
|
{ |
|
if (feof(fichier)) |
{ |
{ |
return(NULL); |
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
} |
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) >= |
|
(ssize_t) deplacement) |
|
{ |
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
octets[i] = *ptr++; |
|
} |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
if ((s_objet = allocation(s_etat_processus, BIN)) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
|
(*((logical8 *) (*s_objet).objet)) = 0; |
|
|
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
(*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i]) |
|
<< (8 * ((deplacement - 1) - i)); |
|
} |
|
|
|
break; |
|
} |
|
|
|
case 0x10: // Scalaire |
|
{ |
|
switch(octets[0] & 0x0C) |
|
{ |
|
case 0x00: // Entier |
|
{ |
switch(octets[0] & 0x03) |
switch(octets[0] & 0x03) |
{ |
{ |
case 0x00: // integer*1 |
case 0x00: // integer*1 |
Line 4612 lecture_fichier_non_formate(struct_proce
|
Line 4751 lecture_fichier_non_formate(struct_proce
|
if (fread(octets, (size_t) sizeof(unsigned char), |
if (fread(octets, (size_t) sizeof(unsigned char), |
deplacement, fichier) != deplacement) |
deplacement, fichier) != deplacement) |
{ |
{ |
(*s_etat_processus).erreur_systeme = |
if (feof(fichier)) |
d_es_erreur_fichier; |
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else |
else |
{ |
{ |
for(i = 0; i < (signed) deplacement; i++) |
if ((longueur_buffer - (ptr - buffer)) >= |
|
(ssize_t) deplacement) |
|
{ |
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
octets[i] = *ptr++; |
|
} |
|
} |
|
else |
{ |
{ |
octets[i] = *ptr++; |
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
return(NULL); |
} |
} |
} |
} |
|
|
|
if ((s_objet = allocation(s_etat_processus, INT)) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
(*((integer8 *) (*s_objet).objet)) = 0; |
(*((integer8 *) (*s_objet).objet)) = 0; |
|
|
for(i = 0; i < (signed) deplacement; i++) |
for(i = 0; i < (signed) deplacement; i++) |
{ |
{ |
(*((integer8 *) (*s_objet).objet)) |= |
(*((integer8 *) (*s_objet).objet)) |= |
octets[i] << (8 * ((deplacement - 1) - i)); |
((integer8) octets[i]) |
|
<< (8 * ((deplacement - 1) - i)); |
} |
} |
|
|
break; |
break; |
Line 4638 lecture_fichier_non_formate(struct_proce
|
Line 4801 lecture_fichier_non_formate(struct_proce
|
|
|
case 0x04: // Réel |
case 0x04: // Réel |
{ |
{ |
if ((s_objet = allocation(s_etat_processus, REL)) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
|
switch(octets[0] & 0x03) |
switch(octets[0] & 0x03) |
{ |
{ |
case 0x00: // real*4 |
case 0x00: // real*4 |
Line 4670 lecture_fichier_non_formate(struct_proce
|
Line 4828 lecture_fichier_non_formate(struct_proce
|
if (fread(octets, (size_t) sizeof(unsigned char), |
if (fread(octets, (size_t) sizeof(unsigned char), |
deplacement, fichier) != deplacement) |
deplacement, fichier) != deplacement) |
{ |
{ |
(*s_etat_processus).erreur_systeme = |
if (feof(fichier)) |
d_es_erreur_fichier; |
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else |
else |
{ |
{ |
for(i = 0; i < (signed) deplacement; i++) |
if ((longueur_buffer - (ptr - buffer)) >= |
|
(ssize_t) deplacement) |
{ |
{ |
octets[i] = *ptr++; |
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
octets[i] = *ptr++; |
|
} |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
} |
} |
} |
} |
|
|
|
if ((s_objet = allocation(s_etat_processus, REL)) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
if (deplacement == 4) |
if (deplacement == 4) |
{ |
{ |
union |
union |
Line 4725 lecture_fichier_non_formate(struct_proce
|
Line 4907 lecture_fichier_non_formate(struct_proce
|
|
|
case 0x08: // Complexe |
case 0x08: // Complexe |
{ |
{ |
|
switch(octets[0] & 0x03) |
|
{ |
|
case 0x00: // complex*8 |
|
{ |
|
deplacement = 4; |
|
break; |
|
} |
|
|
|
case 0x01: // complex*16 |
|
{ |
|
deplacement = 8; |
|
break; |
|
} |
|
|
|
default: |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
if ((s_objet = allocation(s_etat_processus, CPL)) == NULL) |
if ((s_objet = allocation(s_etat_processus, CPL)) == NULL) |
{ |
{ |
return(NULL); |
return(NULL); |
} |
} |
|
|
|
for(j = 0; j < 2; j++) |
|
{ |
|
if (longueur_buffer < 0) |
|
{ |
|
if (fread(octets, (size_t) sizeof(unsigned char), |
|
deplacement, fichier) != deplacement) |
|
{ |
|
liberation(s_etat_processus, s_objet); |
|
|
|
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) >= |
|
(ssize_t) deplacement) |
|
{ |
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
octets[i] = *ptr++; |
|
} |
|
} |
|
else |
|
{ |
|
liberation(s_etat_processus, s_objet); |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
if (deplacement == 4) |
|
{ |
|
union |
|
{ |
|
real4 r4; |
|
integer4 i4; |
|
} eq4; |
|
|
|
eq4.i4 = 0; |
|
|
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
eq4.i4 |= ((integer4) octets[i]) << |
|
(8 * ((deplacement - 1) - i)); |
|
} |
|
|
|
if (j == 0) |
|
{ |
|
(*((complex16 *) (*s_objet).objet)) |
|
.partie_reelle = (real8) eq4.r4; |
|
} |
|
else |
|
{ |
|
(*((complex16 *) (*s_objet).objet)) |
|
.partie_imaginaire = (real8) eq4.r4; |
|
} |
|
} |
|
else |
|
{ |
|
union |
|
{ |
|
real8 r8; |
|
integer8 i8; |
|
} eq8; |
|
|
|
eq8.i8 = 0; |
|
|
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
eq8.i8 |= ((integer8) octets[i]) << |
|
(8 * ((deplacement - 1) - i)); |
|
} |
|
|
|
if (j == 0) |
|
{ |
|
(*((complex16 *) (*s_objet).objet)) |
|
.partie_reelle = (real8) eq8.r8; |
|
} |
|
else |
|
{ |
|
(*((complex16 *) (*s_objet).objet)) |
|
.partie_imaginaire = (real8) eq8.r8; |
|
} |
|
} |
|
} |
|
|
break; |
break; |
} |
} |
|
|
Line 4760 lecture_fichier_non_formate(struct_proce
|
Line 5062 lecture_fichier_non_formate(struct_proce
|
if (fread(octets, (size_t) sizeof(unsigned char), |
if (fread(octets, (size_t) sizeof(unsigned char), |
1, fichier) != 1) |
1, fichier) != 1) |
{ |
{ |
(*s_etat_processus).erreur_systeme = |
if (feof(fichier)) |
d_es_erreur_fichier; |
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else |
else |
{ |
{ |
octets[0] = *ptr++; |
if ((longueur_buffer - (ptr - buffer)) >= 1) |
|
{ |
|
octets[0] = *ptr++; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
} |
} |
|
|
longueur = octets[0]; |
longueur = octets[0]; |
Line 4781 lecture_fichier_non_formate(struct_proce
|
Line 5101 lecture_fichier_non_formate(struct_proce
|
if (fread(octets, (size_t) sizeof(unsigned char), |
if (fread(octets, (size_t) sizeof(unsigned char), |
2, fichier) != 2) |
2, fichier) != 2) |
{ |
{ |
(*s_etat_processus).erreur_systeme = |
if (feof(fichier)) |
d_es_erreur_fichier; |
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else |
else |
{ |
{ |
octets[0] = *ptr++; |
if ((longueur_buffer - (ptr - buffer)) >= 2) |
octets[1] = *ptr++; |
{ |
|
for(j = 0; j < 2; octets[j++] = *ptr++); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
} |
} |
|
|
longueur = (((integer8) (octets[0])) << 8) |
longueur = (((integer8) (octets[0])) << 8) |
Line 4804 lecture_fichier_non_formate(struct_proce
|
Line 5141 lecture_fichier_non_formate(struct_proce
|
if (fread(octets, (size_t) sizeof(unsigned char), |
if (fread(octets, (size_t) sizeof(unsigned char), |
4, fichier) != 4) |
4, fichier) != 4) |
{ |
{ |
(*s_etat_processus).erreur_systeme = |
if (feof(fichier)) |
d_es_erreur_fichier; |
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else |
else |
{ |
{ |
octets[0] = *ptr++; |
if ((longueur_buffer - (ptr - buffer)) >= 4) |
octets[1] = *ptr++; |
{ |
octets[2] = *ptr++; |
for(j = 0; j < 4; octets[j++] = *ptr++); |
octets[3] = *ptr++; |
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
} |
} |
|
|
longueur = (((integer8) (octets[0])) << 24) |
longueur = (((integer8) (octets[0])) << 24) |
Line 4831 lecture_fichier_non_formate(struct_proce
|
Line 5183 lecture_fichier_non_formate(struct_proce
|
if (fread(octets, (size_t) sizeof(unsigned char), |
if (fread(octets, (size_t) sizeof(unsigned char), |
8, fichier) != 8) |
8, fichier) != 8) |
{ |
{ |
(*s_etat_processus).erreur_systeme = |
if (feof(fichier)) |
d_es_erreur_fichier; |
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
else |
else |
{ |
{ |
octets[0] = *ptr++; |
if ((longueur_buffer - (ptr - buffer)) >= 8) |
octets[1] = *ptr++; |
{ |
octets[2] = *ptr++; |
for(j = 0; j < 8; octets[j++] = *ptr++); |
octets[3] = *ptr++; |
} |
octets[4] = *ptr++; |
else |
octets[5] = *ptr++; |
{ |
octets[6] = *ptr++; |
(*s_etat_processus).erreur_execution = |
octets[7] = *ptr++; |
d_ex_syntaxe; |
|
return(NULL); |
|
} |
} |
} |
|
|
longueur = (((integer8) (octets[0])) << 56) |
longueur = (((integer8) (octets[0])) << 56) |
Line 4933 lecture_fichier_non_formate(struct_proce
|
Line 5296 lecture_fichier_non_formate(struct_proce
|
|
|
case 0x80: // Chaîne de caractères |
case 0x80: // Chaîne de caractères |
{ |
{ |
s_objet = NULL; |
if ((octets[0] & 0x08) == 0) // Longueur sur 6 bits |
|
{ |
|
longueur = (octets[0] & 0x07); |
|
} |
|
else |
|
{ |
|
switch(octets[0] & 0x07) |
|
{ |
|
case 0x00: // Longueur sur 8 bits |
|
{ |
|
if (longueur_buffer < 0) |
|
{ |
|
if (fread(octets, (size_t) sizeof(unsigned char), |
|
1, fichier) != 1) |
|
{ |
|
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) >= 1) |
|
{ |
|
octets[0] = *ptr++; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
longueur = octets[0]; |
|
break; |
|
} |
|
|
|
case 0x01: // Longueur sur 16 bits |
|
{ |
|
if (longueur_buffer < 0) |
|
{ |
|
if (fread(octets, (size_t) sizeof(unsigned char), |
|
2, fichier) != 2) |
|
{ |
|
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) >= 2) |
|
{ |
|
for(j = 0; j < 2; octets[j++] = *ptr++); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
longueur = (((integer8) (octets[0])) << 8) |
|
| ((integer8) (octets[1])); |
|
break; |
|
} |
|
|
|
case 0x02: // Longueur sur 32 bits |
|
{ |
|
if (longueur_buffer < 0) |
|
{ |
|
if (fread(octets, (size_t) sizeof(unsigned char), |
|
4, fichier) != 4) |
|
{ |
|
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) >= 4) |
|
{ |
|
for(j = 0; j < 4; octets[j++] = *ptr++); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
longueur = (((integer8) (octets[0])) << 24) |
|
| (((integer8) (octets[1])) << 16) |
|
| (((integer8) (octets[2])) << 8) |
|
| ((integer8) (octets[3])); |
|
break; |
|
} |
|
|
|
case 0x03: // Longueur sur 64 bits |
|
{ |
|
if (longueur_buffer < 0) |
|
{ |
|
if (fread(octets, (size_t) sizeof(unsigned char), |
|
8, fichier) != 8) |
|
{ |
|
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) >= 8) |
|
{ |
|
for(j = 0; j < 8; octets[j++] = *ptr++); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
longueur = (((integer8) (octets[0])) << 56) |
|
| (((integer8) (octets[1])) << 48) |
|
| (((integer8) (octets[2])) << 40) |
|
| (((integer8) (octets[3])) << 32) |
|
| (((integer8) (octets[4])) << 24) |
|
| (((integer8) (octets[5])) << 16) |
|
| (((integer8) (octets[6])) << 8) |
|
| ((integer8) (octets[7])); |
|
break; |
|
} |
|
|
|
default: |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
} |
|
|
|
if (longueur_buffer < 0) |
|
{ |
|
if ((flux = malloc(longueur * sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
if (fread(flux, (size_t) sizeof(unsigned char), |
|
longueur, fichier) != (size_t) longueur) |
|
{ |
|
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) < longueur) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
|
|
flux = ptr; |
|
ptr += longueur; |
|
} |
|
|
|
if ((s_objet = allocation(s_etat_processus, CHN)) == NULL) |
|
{ |
|
if (longueur_buffer < 0) |
|
{ |
|
free(flux); |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
if (((*s_objet).objet = analyse_flux(s_etat_processus, flux, |
|
longueur)) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
|
if (longueur_buffer < 0) |
|
{ |
|
free(flux); |
|
} |
|
|
break; |
break; |
} |
} |
|
|
Line 4953 lecture_fichier_non_formate(struct_proce
|
Line 5558 lecture_fichier_non_formate(struct_proce
|
{ |
{ |
liberation(s_etat_processus, s_objet); |
liberation(s_etat_processus, s_objet); |
|
|
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier; |
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
|
|
Line 4966 lecture_fichier_non_formate(struct_proce
|
Line 5579 lecture_fichier_non_formate(struct_proce
|
{ |
{ |
liberation(s_etat_processus, s_objet); |
liberation(s_etat_processus, s_objet); |
|
|
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier; |
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_erreur_fichier; |
|
} |
|
|
return(NULL); |
return(NULL); |
} |
} |
} |
} |
} |
} |
|
|
|
if (longueur_buffer >= 0) |
|
{ |
|
(*((unsigned char **) argument)) = ptr; |
|
} |
|
|
return(s_objet); |
return(s_objet); |
} |
} |
|
|