--- rpl/src/formateur_fichiers.c 2013/03/16 20:11:29 1.56 +++ rpl/src/formateur_fichiers.c 2013/03/19 11:46:11 1.58 @@ -78,7 +78,7 @@ formateur_fichier(struct_processus *s_et logical1 format_degenere; logical1 presence_signe; - long longueur_chaine_traitee; + unsigned long int longueur_chaine_traitee; struct_liste_chainee *l_atome; struct_liste_chainee *l_element_courant; @@ -111,6 +111,7 @@ formateur_fichier(struct_processus *s_et unsigned long nombre_elements; unsigned long nombre_lignes; + integer8 longueur_fonction; integer8 longueur_liste; integer8 longueur_reelle_chaine; integer8 longueur_totale; @@ -990,7 +991,7 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ - if ((format_sortie != 'B') && (format_sortie != 'U')) + if ((format_sortie != 'B') && (format_sortie != 'N')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; @@ -1190,7 +1191,7 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ - if ((format_sortie != 'C') && (format_sortie != 'U')) + if ((format_sortie != 'C') && (format_sortie != 'N')) { (*s_etat_processus).erreur_execution = d_ex_erreur_format_fichier; @@ -3031,6 +3032,9 @@ formateur_fichier(struct_processus *s_et * 1101 10 11 matrice complex*16 (dimensions integer*4) * 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 : * 00 : integer*1 * 01 : integer*2 @@ -3057,6 +3061,12 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'L'; + longueur_champ = 8; + } + if (format_sortie != 'L') { (*s_etat_processus).erreur_execution = @@ -3103,6 +3113,19 @@ 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, (unsigned char *) (*s_objet).objet); @@ -3258,6 +3281,12 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'C'; + longueur = 8; + } + if (format_sortie != 'C') { (*s_etat_processus).erreur_execution = @@ -3282,6 +3311,12 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'I'; + longueur = 8; + } + if ((format_sortie != 'I') && (format_sortie != 'R') && (format_sortie != 'C')) { @@ -3303,9 +3338,119 @@ formateur_fichier(struct_processus *s_et /* -------------------------------------------------------------------------------- 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) || ((*s_objet).type == RPN)) @@ -3561,6 +3706,12 @@ formateur_fichier(struct_processus *s_et 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); @@ -3701,6 +3852,12 @@ formateur_fichier(struct_processus *s_et -------------------------------------------------------------------------------- */ + if (format_sortie == 'N') + { + format_sortie = 'R'; + longueur = 8; + } + if ((format_sortie != 'R') && (format_sortie != 'C')) { (*s_etat_processus).erreur_execution = @@ -5700,6 +5857,273 @@ lecture_fichier_non_formate(struct_proce 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: { (*s_etat_processus).erreur_execution = d_ex_syntaxe;