version 1.53, 2013/03/10 22:15:48
|
version 1.54, 2013/03/11 11:07:24
|
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 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 4588 lecture_fichier_non_formate(struct_proce
|
Line 4625 lecture_fichier_non_formate(struct_proce
|
|
|
switch(octets[0] & 0xF0) |
switch(octets[0] & 0xF0) |
{ |
{ |
|
case 0x00: // Binaire |
|
{ |
|
switch(octets[0] & 0x0F) |
|
{ |
|
case 0x01: // logical*1 |
|
{ |
|
deplacement = 1; |
|
break; |
|
} |
|
|
|
case 0x02: // logical*2 |
|
{ |
|
deplacement = 2; |
|
break; |
|
} |
|
|
|
case 0x04: // logical*4 |
|
{ |
|
deplacement = 4; |
|
break; |
|
} |
|
|
|
case 0x08: // logical*8 |
|
{ |
|
deplacement = 8; |
|
break; |
|
} |
|
|
|
default: |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
if (longueur_buffer < 0) |
|
{ |
|
if (fread(octets, (size_t) sizeof(unsigned char), |
|
deplacement, fichier) != deplacement) |
|
{ |
|
if (feof(fichier)) |
|
{ |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_syntaxe; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_erreur_fichier; |
|
} |
|
|
|
return(NULL); |
|
} |
|
} |
|
else |
|
{ |
|
if ((longueur_buffer - (ptr - buffer)) >= |
|
(ssize_t) deplacement) |
|
{ |
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
octets[i] = *ptr++; |
|
} |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_execution = d_ex_syntaxe; |
|
return(NULL); |
|
} |
|
} |
|
|
|
if ((s_objet = allocation(s_etat_processus, BIN)) == NULL) |
|
{ |
|
return(NULL); |
|
} |
|
|
|
(*((logical8 *) (*s_objet).objet)) = 0; |
|
|
|
for(i = 0; i < (signed) deplacement; i++) |
|
{ |
|
(*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i]) |
|
<< (8 * ((deplacement - 1) - i)); |
|
} |
|
|
|
break; |
|
} |
|
|
case 0x10: // Scalaire |
case 0x10: // Scalaire |
{ |
{ |
switch(octets[0] & 0x0C) |
switch(octets[0] & 0x0C) |
Line 4667 lecture_fichier_non_formate(struct_proce
|
Line 4792 lecture_fichier_non_formate(struct_proce
|
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; |