version 1.57, 2013/03/18 15:53:48
|
version 1.59, 2013/03/19 12:27:56
|
Line 78 formateur_fichier(struct_processus *s_et
|
Line 78 formateur_fichier(struct_processus *s_et
|
logical1 format_degenere; |
logical1 format_degenere; |
logical1 presence_signe; |
logical1 presence_signe; |
|
|
long longueur_chaine_traitee; |
unsigned long int 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; |
Line 111 formateur_fichier(struct_processus *s_et
|
Line 111 formateur_fichier(struct_processus *s_et
|
unsigned long nombre_elements; |
unsigned long nombre_elements; |
unsigned long nombre_lignes; |
unsigned long nombre_lignes; |
|
|
|
integer8 longueur_fonction; |
integer8 longueur_liste; |
integer8 longueur_liste; |
integer8 longueur_reelle_chaine; |
integer8 longueur_reelle_chaine; |
integer8 longueur_totale; |
integer8 longueur_totale; |
Line 3031 formateur_fichier(struct_processus *s_et
|
Line 3032 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 3334 formateur_fichier(struct_processus *s_et
|
Line 3338 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 = strlen((*((struct_fonction *) (*s_objet).objet)) |
|
.nom_fonction); |
|
|
|
if (longueur_fonction < (1LL << 3)) |
|
{ |
|
if ((chaine = malloc((1 + longueur_fonction + 8) |
|
* sizeof(unsigned char)))== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = 0xE0 | (longueur_fonction & 0x7); |
|
|
|
strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet)) |
|
.nom_fonction); |
|
} |
|
else if (longueur_fonction < (1LL << 8)) |
|
{ |
|
if ((chaine = malloc((2 + longueur_fonction + 8) |
|
* sizeof(unsigned char)))== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = 0xE0 | 0x08; |
|
chaine[1] = (unsigned char) (longueur_fonction & 0xFF); |
|
|
|
strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet)) |
|
.nom_fonction); |
|
} |
|
else if (longueur_fonction < (1LL << 16)) |
|
{ |
|
if ((chaine = malloc((3 + longueur_fonction + 8) |
|
* sizeof(unsigned char)))== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = 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); |
|
} |
|
else if (longueur_fonction < (1LL << 32)) |
|
{ |
|
if ((chaine = malloc((5 + longueur_fonction + 8) |
|
* sizeof(unsigned char)))== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = 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); |
|
} |
|
else |
|
{ |
|
if ((chaine = malloc((9 + longueur_fonction + 8) |
|
* sizeof(unsigned char)))== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return(NULL); |
|
} |
|
|
|
chaine[0] = 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); |
|
} |
|
|
|
for(i = 1; i <= 8; i++) |
|
{ |
|
chaine[longueur_fonction + i] = (unsigned char) |
|
(((*((struct_fonction *) (*s_objet).objet)) |
|
.nombre_arguments >> ((8 - i) * 8)) & 0xFF); |
|
} |
|
|
|
(*longueur_effective) = longueur_fonction + 9; |
} |
} |
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 3524 formateur_fichier(struct_processus *s_et
|
Line 3638 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, (longueur_totale + |
Line 3668 formateur_fichier(struct_processus *s_et
|
Line 3798 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) || |
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 4778 lecture_fichier_non_formate(struct_proce
|
Line 4916 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 4824 lecture_fichier_non_formate(struct_proce
|
Line 4963 lecture_fichier_non_formate(struct_proce
|
} |
} |
} |
} |
|
|
switch(octets[0] & 0xF0) |
switch(type_objet = (octets[0] & 0xF0)) |
{ |
{ |
case 0x00: // Binaire |
case 0x00: // Binaire |
{ |
{ |
Line 5247 lecture_fichier_non_formate(struct_proce
|
Line 5386 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 5431 lecture_fichier_non_formate(struct_proce
|
Line 5572 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 5743 lecture_fichier_non_formate(struct_proce
|
Line 5901 lecture_fichier_non_formate(struct_proce
|
break; |
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((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), |
|
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; |