--- rpl/src/types.c 2011/06/27 09:05:02 1.36 +++ rpl/src/types.c 2022/09/07 13:40:42 1.99 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.0 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.34 + Copyright (C) 1989-2021 Dr. BERTRAND Joël This file is part of RPL/2. @@ -38,7 +38,25 @@ void recherche_type(struct_processus *s_etat_processus) { - int nombre_elements_convertis; + integer8 i; + integer8 j; + integer8 niveau; + integer8 niveau_maximal; + integer8 nombre_colonnes; + integer8 nombre_egalites; + integer8 nombre_elements; + integer8 nombre_elements_convertis; + integer8 nombre_exposants; + integer8 nombre_lignes; + integer8 nombre_lignes_a_supprimer; + integer8 nombre_points; + integer8 nombre_virgules; + integer8 position_courante; + integer8 profondeur_finale; + integer8 profondeur_initiale; + integer8 sauvegarde_niveau_courant; + integer8 sauvegarde_longueur_definitions_chainees; + integer8 (*__type_new)(struct_processus *, void **); struct_liste_chainee *l_base_liste_fonctions; struct_liste_chainee *l_base_liste_decomposition; @@ -49,6 +67,7 @@ recherche_type(struct_processus *s_etat_ struct_liste_pile_systeme *s_sauvegarde_pile; struct_objet *s_objet; + struct_objet *s_objet_registre; struct_objet *s_sous_objet; logical1 drapeau_chaine; @@ -59,6 +78,7 @@ recherche_type(struct_processus *s_etat_ logical1 drapeau_valeur_reelle; logical1 erreur; logical1 erreur_lecture_binaire; + logical1 tri_acheve; logical8 ancienne_valeur_base; logical8 valeur_base; @@ -81,38 +101,18 @@ recherche_type(struct_processus *s_etat_ unsigned char *tampon; unsigned char variable_implicite; - unsigned long i; - unsigned long j; - unsigned long niveau; - unsigned long niveau_maximal; - unsigned long nombre_colonnes; - unsigned long nombre_egalites; - unsigned long nombre_elements; - unsigned long nombre_exposants; - unsigned long nombre_lignes; - unsigned long nombre_lignes_a_supprimer; - unsigned long nombre_points; - unsigned long nombre_virgules; - unsigned long position_courante; - unsigned long profondeur_finale; - unsigned long profondeur_initiale; - unsigned long sauvegarde_niveau_courant; - unsigned long sauvegarde_longueur_definitions_chainees; - void *element; - s_objet = (struct_objet *) malloc(sizeof(struct_objet)); - element = NULL; - nombre_egalites = 0; - i = 0; - - if (s_objet == NULL) + if ((s_objet = allocation(s_etat_processus, NON)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return; } - initialisation_objet(s_objet); + element = NULL; + nombre_egalites = 0; + i = 0; + registre_test = (*s_etat_processus).test_instruction; registre_instruction_valide = (*s_etat_processus).instruction_valide; registre_interruption = (*s_etat_processus).traitement_interruptible; @@ -145,8 +145,8 @@ recherche_type(struct_processus *s_etat_ */ if (((*((struct_fonction *) element)).nom_fonction = - conversion_majuscule((*s_etat_processus) - .instruction_courante)) == NULL) + conversion_majuscule(s_etat_processus, + (*s_etat_processus).instruction_courante)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -193,7 +193,7 @@ recherche_type(struct_processus *s_etat_ } else { - if ((instruction_majuscule = conversion_majuscule( + if ((instruction_majuscule = conversion_majuscule(s_etat_processus, (*s_etat_processus).instruction_courante)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -208,7 +208,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).test_instruction = 'N'; analyse(s_etat_processus, NULL); (*s_etat_processus).test_instruction = registre_test_bis; - free(s_objet); + liberation(s_etat_processus, s_objet); } else { @@ -262,6 +262,57 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).instruction_valide = registre_instruction_valide; +/* +-------------------------------------------------------------------------------- + Types externes +-------------------------------------------------------------------------------- +*/ + + l_element_courant = (*s_etat_processus).s_bibliotheques; + + while(l_element_courant != NULL) + { + if ((__type_new = dlsym((*((struct_bibliotheque *) + (*l_element_courant).donnee)).descripteur, "__type_new")) + != NULL) + { + if (((*s_objet).extension_type = __type_new(s_etat_processus, + &element)) != 0) + { + // Le type peut être converti. + + (*s_objet).objet = element; + (*s_objet).type = EXT; + (*s_objet).descripteur_bibliotheque = + (*((struct_bibliotheque *) + (*l_element_courant).donnee)).descripteur; + + if (empilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), s_objet) + == d_erreur) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + } + + l_element_courant = (*l_element_courant).suivant; + } + +/* +-------------------------------------------------------------------------------- + Types internes +-------------------------------------------------------------------------------- +*/ + switch(*((*s_etat_processus).instruction_courante)) { @@ -273,8 +324,6 @@ recherche_type(struct_processus *s_etat_ case '(' : { - (*s_objet).type = CPL; - element = (void *) ((struct_complexe16 *) malloc( sizeof(struct_complexe16))); @@ -292,10 +341,10 @@ recherche_type(struct_processus *s_etat_ sauvegarde_longueur_definitions_chainees = (*s_etat_processus).longueur_definitions_chainees; - tampon = (unsigned char *) malloc( + tampon = (unsigned char *) malloc(((size_t) (((*s_etat_processus).longueur_definitions_chainees - = strlen((*s_etat_processus).instruction_courante) - + 4) + 1) * sizeof(unsigned char)); + = (integer8) strlen((*s_etat_processus) + .instruction_courante) + 4) + 1)) * sizeof(unsigned char)); if (tampon == NULL) { @@ -397,7 +446,7 @@ recherche_type(struct_processus *s_etat_ sauvegarde_longueur_definitions_chainees; free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).traitement_interruptible = registre_interruption; @@ -432,10 +481,10 @@ recherche_type(struct_processus *s_etat_ { (*s_etat_processus).erreur_execution = d_ex_syntaxe; - free(s_objet); + liberation(s_etat_processus, s_objet); free(element); - for(i = 0; i < (unsigned long) nombre_elements_convertis; i++) + for(i = 0; i < nombre_elements_convertis; i++) { if (depilement(s_etat_processus, &((*s_etat_processus) .l_base_pile), &s_sous_objet) == d_erreur) @@ -461,7 +510,7 @@ recherche_type(struct_processus *s_etat_ if ((*s_sous_objet).type == INT) { (*((struct_complexe16 *) element)).partie_imaginaire = - (*((integer8 *) (*s_sous_objet).objet)); + (real8) (*((integer8 *) (*s_sous_objet).objet)); } else if ((*s_sous_objet).type == REL) { @@ -473,7 +522,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).erreur_execution = d_ex_syntaxe; free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); liberation(s_etat_processus, s_sous_objet); @@ -491,7 +540,8 @@ recherche_type(struct_processus *s_etat_ if ((*s_sous_objet).type == INT) { (*((struct_complexe16 *) element)).partie_reelle = - (*((integer8 *) (*s_sous_objet).objet)); + (real8) (*((integer8 *) + (*s_sous_objet).objet)); } else if ((*s_sous_objet).type == REL) { @@ -503,7 +553,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).erreur_execution = d_ex_syntaxe; free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); liberation(s_etat_processus, s_sous_objet); @@ -517,6 +567,7 @@ recherche_type(struct_processus *s_etat_ } } + (*s_objet).type = CPL; break; } @@ -528,8 +579,6 @@ recherche_type(struct_processus *s_etat_ case '#' : { - (*s_objet).type = BIN; - element = (void *) ((logical8 *) malloc( sizeof(logical8))); @@ -548,7 +597,8 @@ recherche_type(struct_processus *s_etat_ { case 'b' : { - i = strlen((*s_etat_processus).instruction_courante) - 2; + i = ((integer8) strlen((*s_etat_processus) + .instruction_courante)) - 2; valeur_base = 1; (*((logical8 *) element)) = 0; @@ -580,7 +630,7 @@ recherche_type(struct_processus *s_etat_ if (i != 0) { free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; @@ -622,7 +672,8 @@ recherche_type(struct_processus *s_etat_ case 'o' : { - i = strlen((*s_etat_processus).instruction_courante) - 2; + i = ((integer8) strlen((*s_etat_processus) + .instruction_courante)) - 2; valeur_base = 1; (*((logical8 *) element)) = 0; @@ -684,7 +735,7 @@ recherche_type(struct_processus *s_etat_ if (i != 0) { free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; @@ -726,7 +777,8 @@ recherche_type(struct_processus *s_etat_ case 'd' : { - i = strlen((*s_etat_processus).instruction_courante) - 2; + i = ((integer8) strlen((*s_etat_processus) + .instruction_courante)) - 2; valeur_base = 1; (*((logical8 *) element)) = 0; @@ -798,7 +850,7 @@ recherche_type(struct_processus *s_etat_ if (i != 0) { free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; @@ -840,7 +892,8 @@ recherche_type(struct_processus *s_etat_ case 'h' : { - i = strlen((*s_etat_processus).instruction_courante) - 2; + i = ((integer8) strlen((*s_etat_processus) + .instruction_courante)) - 2; valeur_base = 1; (*((logical8 *) element)) = 0; @@ -942,7 +995,7 @@ recherche_type(struct_processus *s_etat_ if (i != 0) { free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; @@ -993,7 +1046,7 @@ recherche_type(struct_processus *s_etat_ (erreur_lecture_binaire == d_vrai)) { free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -1001,6 +1054,7 @@ recherche_type(struct_processus *s_etat_ return; } + (*s_objet).type = BIN; break; } @@ -1061,7 +1115,7 @@ recherche_type(struct_processus *s_etat_ if (niveau != 0) { - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -1092,10 +1146,11 @@ recherche_type(struct_processus *s_etat_ sauvegarde_longueur_definitions_chainees = (*s_etat_processus).longueur_definitions_chainees; - tampon = (unsigned char *) malloc( + tampon = (unsigned char *) malloc(((size_t) (((*s_etat_processus).longueur_definitions_chainees - = strlen((*s_etat_processus).instruction_courante) - + 4) + 1) * sizeof(unsigned char)); + = (integer8) strlen((*s_etat_processus) + .instruction_courante) + 4) + 1)) * + sizeof(unsigned char)); if (tampon == NULL) { @@ -1217,7 +1272,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).longueur_definitions_chainees = sauvegarde_longueur_definitions_chainees; - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -1268,7 +1323,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).longueur_definitions_chainees = sauvegarde_longueur_definitions_chainees; - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -1316,22 +1371,23 @@ recherche_type(struct_processus *s_etat_ if (drapeau_complexe == d_vrai) { (*((struct_vecteur *) element)).tableau = (void *) - ((struct_complexe16 *) malloc(nombre_colonnes * + ((struct_complexe16 *) malloc(((size_t) + nombre_colonnes) * sizeof(struct_complexe16))); (*((struct_vecteur *) element)).type = 'C'; } else if (drapeau_reel == d_vrai) { (*((struct_vecteur *) element)).tableau = (void *) - ((real8 *) malloc(nombre_colonnes * + ((real8 *) malloc(((size_t) nombre_colonnes) * sizeof(real8))); (*((struct_vecteur *) element)).type = 'R'; } else { (*((struct_vecteur *) element)).tableau = (void *) - ((integer8 *) malloc(nombre_colonnes * - sizeof(integer8))); + ((integer8 *) malloc(((size_t) nombre_colonnes) + * sizeof(integer8))); (*((struct_vecteur *) element)).type = 'I'; } @@ -1345,7 +1401,7 @@ recherche_type(struct_processus *s_etat_ } erreur = d_absence_erreur; - free(s_objet); + s_objet_registre = s_objet; for(i = 0; (i < nombre_colonnes) && (erreur == d_absence_erreur); i++) @@ -1442,6 +1498,8 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus) .traitement_interruptible = registre_interruption; + liberation(s_etat_processus, + s_objet_registre); return; } @@ -1454,6 +1512,7 @@ recherche_type(struct_processus *s_etat_ free((*((struct_vecteur *) element)).tableau); free(element); + liberation(s_etat_processus, s_objet_registre); (*s_etat_processus).traitement_interruptible = registre_interruption; return; @@ -1461,6 +1520,8 @@ recherche_type(struct_processus *s_etat_ } else { + liberation(s_etat_processus, s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_pile_vide; (*s_etat_processus).traitement_interruptible = registre_interruption; @@ -1468,18 +1529,7 @@ recherche_type(struct_processus *s_etat_ } } - s_objet = (struct_objet *) malloc(sizeof(struct_objet)); - - if (s_objet == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - (*s_etat_processus).traitement_interruptible = - registre_interruption; - return; - } - - initialisation_objet(s_objet); + s_objet = s_objet_registre; if (drapeau_complexe == d_vrai) { @@ -1510,10 +1560,11 @@ recherche_type(struct_processus *s_etat_ sauvegarde_longueur_definitions_chainees = (*s_etat_processus).longueur_definitions_chainees; - tampon = (unsigned char *) malloc( + tampon = (unsigned char *) malloc(((size_t) (((*s_etat_processus).longueur_definitions_chainees - = strlen((*s_etat_processus).instruction_courante) - + 4) + 1) * sizeof(unsigned char)); + = (integer8) strlen((*s_etat_processus) + .instruction_courante) + 4) + 1)) * + sizeof(unsigned char)); if (tampon == NULL) { @@ -1636,7 +1687,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).position_courante = position_courante; - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -1688,7 +1739,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).position_courante = position_courante; - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -1771,7 +1822,7 @@ recherche_type(struct_processus *s_etat_ } free(element); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).traitement_interruptible = registre_interruption; @@ -1792,7 +1843,7 @@ recherche_type(struct_processus *s_etat_ l_element_courant = (*l_element_courant).suivant; } - free(s_objet); + s_objet_registre = s_objet; if ((*s_etat_processus).erreur_execution == d_ex) { @@ -1800,9 +1851,11 @@ recherche_type(struct_processus *s_etat_ { if (((*((struct_matrice *) element)).tableau = (void **) ((struct_complexe16 **) - malloc(nombre_lignes * sizeof( + malloc(((size_t) nombre_lignes) * sizeof( struct_complexe16 *)))) == NULL) { + liberation(s_etat_processus, s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; (*s_etat_processus).traitement_interruptible = @@ -1817,9 +1870,12 @@ recherche_type(struct_processus *s_etat_ if ((((*((struct_matrice *) element)).tableau)[i] = (void *) ((struct_complexe16 *) - malloc(nombre_colonnes * sizeof( - struct_complexe16)))) == NULL) + malloc(((size_t) nombre_colonnes) * + sizeof(struct_complexe16)))) == NULL) { + liberation(s_etat_processus, + s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; (*s_etat_processus) @@ -1832,10 +1888,12 @@ recherche_type(struct_processus *s_etat_ else if (drapeau_reel == d_vrai) { if (((*((struct_matrice *) element)).tableau = - (void **) ((real8 **) - malloc(nombre_lignes * sizeof(real8 *)))) + (void **) ((real8 **) malloc(((size_t) + nombre_lignes) * sizeof(real8 *)))) == NULL) { + liberation(s_etat_processus, s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; (*s_etat_processus).traitement_interruptible = @@ -1849,9 +1907,12 @@ recherche_type(struct_processus *s_etat_ { if ((((*((struct_matrice *)element)).tableau)[i] = (void *) ((real8 *) - malloc(nombre_colonnes * + malloc(((size_t) nombre_colonnes) * sizeof(real8)))) == NULL) { + liberation(s_etat_processus, + s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; (*s_etat_processus) @@ -1865,9 +1926,11 @@ recherche_type(struct_processus *s_etat_ { if (((*((struct_matrice *) element)).tableau = (void **) ((integer8 **) - malloc(nombre_lignes * + malloc(((size_t) nombre_lignes) * sizeof(integer8 *)))) == NULL) { + liberation(s_etat_processus, s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; (*s_etat_processus).traitement_interruptible = @@ -1882,9 +1945,12 @@ recherche_type(struct_processus *s_etat_ if ((((*((struct_matrice *) element)).tableau)[i] = (void *) ((integer8 *) - malloc(nombre_colonnes * + malloc(((size_t) nombre_colonnes) * sizeof(integer8)))) == NULL) { + liberation(s_etat_processus, + s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; (*s_etat_processus) @@ -2027,6 +2093,9 @@ recherche_type(struct_processus *s_etat_ .l_base_pile), &s_objet) == d_erreur) { + liberation(s_etat_processus, + s_objet_registre); + (*s_etat_processus) .traitement_interruptible = registre_interruption; @@ -2050,6 +2119,9 @@ recherche_type(struct_processus *s_etat_ .tableau); free(element); + liberation(s_etat_processus, + s_objet_registre); + (*s_etat_processus) .traitement_interruptible = registre_interruption; @@ -2058,6 +2130,9 @@ recherche_type(struct_processus *s_etat_ } else { + liberation(s_etat_processus, + s_objet_registre); + (*s_etat_processus).erreur_systeme = d_es_pile_vide; (*s_etat_processus).traitement_interruptible = @@ -2066,18 +2141,7 @@ recherche_type(struct_processus *s_etat_ } } - s_objet = (struct_objet *) malloc(sizeof(struct_objet)); - - if (s_objet == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - (*s_etat_processus).traitement_interruptible = - registre_interruption; - return; - } - - initialisation_objet(s_objet); + s_objet = s_objet_registre; if (drapeau_complexe == d_vrai) { @@ -2128,10 +2192,10 @@ recherche_type(struct_processus *s_etat_ sauvegarde_longueur_definitions_chainees = (*s_etat_processus).longueur_definitions_chainees; - tampon = (unsigned char *) malloc( + tampon = (unsigned char *) malloc(((size_t) (((*s_etat_processus).longueur_definitions_chainees = - strlen((*s_etat_processus).instruction_courante) + 4) + 1) - * sizeof(unsigned char)); + (integer8) strlen((*s_etat_processus) + .instruction_courante) + 4) + 1)) * sizeof(unsigned char)); if (tampon == NULL) { @@ -2218,13 +2282,32 @@ recherche_type(struct_processus *s_etat_ if ((*s_etat_processus).definitions_chainees [(*s_etat_processus).position_courante] == '"') { - if (drapeau_chaine == d_faux) + if ((*s_etat_processus).position_courante > 0) { - drapeau_chaine = d_vrai; + if ((*s_etat_processus).definitions_chainees + [(*s_etat_processus).position_courante - 1] + != '\\') + { + if (drapeau_chaine == d_faux) + { + drapeau_chaine = d_vrai; + } + else + { + drapeau_chaine = d_faux; + } + } } - else + else { - drapeau_chaine = d_faux; + if (drapeau_chaine == d_faux) + { + drapeau_chaine = d_vrai; + } + else + { + drapeau_chaine = d_faux; + } } } else if (drapeau_chaine == d_faux) @@ -2287,7 +2370,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; free((*s_etat_processus).definitions_chainees); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).definitions_chainees = definitions_chainees_precedentes; @@ -2368,7 +2451,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; free((*s_etat_processus).definitions_chainees); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).definitions_chainees = definitions_chainees_precedentes; @@ -2419,7 +2502,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).niveau_courant = sauvegarde_niveau_courant; free((*s_etat_processus).definitions_chainees); - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).definitions_chainees = definitions_chainees_precedentes; @@ -2459,8 +2542,7 @@ recherche_type(struct_processus *s_etat_ profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle; l_element_courant = NULL; - - free(s_objet); + s_objet_registre = s_objet; for(i = 0; i < (profondeur_finale - profondeur_initiale); i++) { @@ -2468,6 +2550,7 @@ recherche_type(struct_processus *s_etat_ &((*s_etat_processus).l_base_pile), &s_objet) == d_erreur) { + liberation(s_etat_processus, s_objet_registre); (*s_etat_processus).traitement_interruptible = registre_interruption; return; @@ -2476,23 +2559,14 @@ recherche_type(struct_processus *s_etat_ if (empilement(s_etat_processus, &l_element_courant, s_objet) == d_erreur) { + liberation(s_etat_processus, s_objet_registre); (*s_etat_processus).traitement_interruptible = registre_interruption; return; } } - s_objet = (struct_objet *) malloc(sizeof(struct_objet)); - - if (s_objet == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - (*s_etat_processus).traitement_interruptible = - registre_interruption; - return; - } - - initialisation_objet(s_objet); + s_objet = s_objet_registre; (*s_objet).type = LST; element = (void *) l_element_courant; @@ -2528,7 +2602,7 @@ recherche_type(struct_processus *s_etat_ free(l_element_courant_fonctions); } - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).traitement_interruptible = registre_interruption; @@ -2567,7 +2641,8 @@ recherche_type(struct_processus *s_etat_ * puis on renvoie une erreur. */ - free(s_objet); + (*s_objet).type = NON; + liberation(s_etat_processus, s_objet); l_element_courant = l_base_liste_decomposition; @@ -2644,7 +2719,8 @@ recherche_type(struct_processus *s_etat_ * elle est convertie en majuscules. */ - tampon = conversion_majuscule((*((struct_fonction *) + tampon = conversion_majuscule(s_etat_processus, + (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) .nom_fonction); @@ -2682,6 +2758,7 @@ recherche_type(struct_processus *s_etat_ { if ((fonction_majuscule = conversion_majuscule( + s_etat_processus, (*((struct_fonction *) ((*l_element_courant_fonctions) .donnee))).nom_fonction)) == NULL) @@ -2833,6 +2910,7 @@ recherche_type(struct_processus *s_etat_ free(l_element_courant_fonctions); } + (*s_etat_processus).autorisation_empilement_programme = 'Y'; break; } @@ -2868,6 +2946,16 @@ recherche_type(struct_processus *s_etat_ (*(--ptr_ecriture)) = d_code_fin_chaine; + if (validation_chaine((unsigned char *) element) == d_faux) + { + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + + free(element); + return; + } + break; } @@ -2883,13 +2971,15 @@ recherche_type(struct_processus *s_etat_ { // Tableau + (*s_etat_processus).type_en_cours = TBL; sauvegarde_longueur_definitions_chainees = (*s_etat_processus).longueur_definitions_chainees; - tampon = (unsigned char *) malloc( + tampon = (unsigned char *) malloc(((size_t) (((*s_etat_processus).longueur_definitions_chainees - = strlen((*s_etat_processus).instruction_courante) - + 2) + 1) * sizeof(unsigned char)); + = (integer8) strlen((*s_etat_processus) + .instruction_courante) + 2) + 1)) * + sizeof(unsigned char)); if (tampon == NULL) { @@ -2943,14 +3033,21 @@ recherche_type(struct_processus *s_etat_ (*(*s_etat_processus).l_base_pile_systeme) .retour_definition = 'Y'; + (*(*s_etat_processus).l_base_pile_systeme) + .origine_routine_evaluation = 'N'; (*s_etat_processus).niveau_courant = 0; (*s_etat_processus).autorisation_empilement_programme = 'N'; + + tampon = (*s_etat_processus).instruction_courante; + autorisation_evaluation_nom = (*s_etat_processus) + .autorisation_evaluation_nom; + (*s_etat_processus).autorisation_evaluation_nom = 'N'; + registre_mode_execution_programme = (*s_etat_processus).mode_execution_programme; (*s_etat_processus).mode_execution_programme = 'Y'; (*s_etat_processus).erreur_scrutation = d_faux; - tampon = (*s_etat_processus).instruction_courante; nombre_lignes_a_supprimer = (*s_etat_processus).hauteur_pile_operationnelle; @@ -2999,6 +3096,8 @@ recherche_type(struct_processus *s_etat_ } (*s_etat_processus).instruction_courante = tampon; + (*s_etat_processus).autorisation_evaluation_nom = + autorisation_evaluation_nom; effacement_pile_systeme(s_etat_processus); (*s_etat_processus).l_base_pile_systeme = @@ -3017,7 +3116,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).position_courante = position_courante; - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -3052,6 +3151,8 @@ recherche_type(struct_processus *s_etat_ } (*s_etat_processus).instruction_courante = tampon; + (*s_etat_processus).autorisation_evaluation_nom = + autorisation_evaluation_nom; effacement_pile_systeme(s_etat_processus); (*s_etat_processus).l_base_pile_systeme = @@ -3070,7 +3171,7 @@ recherche_type(struct_processus *s_etat_ (*s_etat_processus).position_courante = position_courante; - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -3079,6 +3180,8 @@ recherche_type(struct_processus *s_etat_ } (*s_etat_processus).instruction_courante = tampon; + (*s_etat_processus).autorisation_evaluation_nom = + autorisation_evaluation_nom; (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; (*s_etat_processus).niveau_courant = @@ -3116,7 +3219,8 @@ recherche_type(struct_processus *s_etat_ (*((struct_tableau *) element)).nombre_elements = nombre_lignes; if (((*((struct_tableau *) element)).elements = - malloc(nombre_lignes * sizeof(struct_objet *))) == NULL) + malloc(((size_t) nombre_lignes) * + sizeof(struct_objet *))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -3149,9 +3253,11 @@ recherche_type(struct_processus *s_etat_ { // Définition + (*s_etat_processus).type_en_cours = RPN; + if (strlen((*s_etat_processus).instruction_courante) < 5) { - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -3163,7 +3269,7 @@ recherche_type(struct_processus *s_etat_ != 0) && (strcmp((*s_etat_processus) .instruction_courante, "<<") != 0)) { - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = @@ -3184,7 +3290,7 @@ recherche_type(struct_processus *s_etat_ d_es_allocation_memoire; } - free(s_objet); + liberation(s_etat_processus, s_objet); (*s_etat_processus).traitement_interruptible = registre_interruption; @@ -3213,6 +3319,410 @@ recherche_type(struct_processus *s_etat_ /* -------------------------------------------------------------------------------- + Enregistrement +-------------------------------------------------------------------------------- +*/ + + case '|' : + { + if ((*s_etat_processus).instruction_courante[1] == '[') + { + (*s_etat_processus).type_en_cours = REC; + sauvegarde_longueur_definitions_chainees = + (*s_etat_processus).longueur_definitions_chainees; + + tampon = (unsigned char *) malloc(((size_t) + (((*s_etat_processus).longueur_definitions_chainees + = (integer8) strlen((*s_etat_processus) + .instruction_courante) + 2) + 1)) * + sizeof(unsigned char)); + + if (tampon == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + strcpy(tampon, "<< "); + ptr_ecriture = tampon + 3; + ptr_lecture = (*s_etat_processus).instruction_courante + 2; + + while((*ptr_lecture) != d_code_fin_chaine) + { + *ptr_ecriture++ = *ptr_lecture++; + } + + ptr_ecriture -= 2; + (*ptr_ecriture) = d_code_fin_chaine; + strcat(ptr_ecriture, " >>"); + + position_courante = (*s_etat_processus).position_courante; + (*s_etat_processus).position_courante = 0; + + profondeur_initiale = (*s_etat_processus) + .hauteur_pile_operationnelle; + +/* +-- On met les éléments du tableau dans la pile opérationnelle ------------------ +*/ + + (*s_etat_processus).niveau_recursivite++; + definitions_chainees_precedentes = (*s_etat_processus) + .definitions_chainees; + (*s_etat_processus).definitions_chainees = tampon; + + s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme; + sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant; + + (*s_etat_processus).l_base_pile_systeme = NULL; + empilement_pile_systeme(s_etat_processus); + + if ((*s_etat_processus).erreur_systeme != d_es) + { + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + (*(*s_etat_processus).l_base_pile_systeme) + .retour_definition = 'Y'; + (*(*s_etat_processus).l_base_pile_systeme) + .origine_routine_evaluation = 'N'; + (*s_etat_processus).niveau_courant = 0; + (*s_etat_processus).autorisation_empilement_programme = 'N'; + + tampon = (*s_etat_processus).instruction_courante; + autorisation_evaluation_nom = (*s_etat_processus) + .autorisation_evaluation_nom; + (*s_etat_processus).autorisation_evaluation_nom = 'N'; + + registre_mode_execution_programme = + (*s_etat_processus).mode_execution_programme; + (*s_etat_processus).mode_execution_programme = 'Y'; + (*s_etat_processus).erreur_scrutation = d_faux; + + nombre_lignes_a_supprimer = + (*s_etat_processus).hauteur_pile_operationnelle; + + if ((*s_etat_processus).profilage == d_vrai) + { + profilage(s_etat_processus, "RPL/2 internals"); + + if ((*s_etat_processus).erreur_systeme != d_es) + { + return; + } + } + + registre_recherche_type = (*s_etat_processus).recherche_type; + (*s_etat_processus).recherche_type = 'Y'; + + variable_implicite = + (*s_etat_processus).autorisation_nom_implicite; + (*s_etat_processus).autorisation_nom_implicite = 'Y'; + + if (sequenceur(s_etat_processus) == d_erreur) + { + (*s_etat_processus).autorisation_nom_implicite = + variable_implicite; + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + (*s_etat_processus).recherche_type = + registre_recherche_type; + (*s_etat_processus).mode_execution_programme = + registre_mode_execution_programme; + nombre_lignes_a_supprimer = + (*s_etat_processus).hauteur_pile_operationnelle + - nombre_lignes_a_supprimer; + + for(i = 0; i < nombre_lignes_a_supprimer; i++) + { + if (depilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + &s_sous_objet) == d_erreur) + { + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + liberation(s_etat_processus, s_sous_objet); + } + + (*s_etat_processus).instruction_courante = tampon; + (*s_etat_processus).autorisation_evaluation_nom = + autorisation_evaluation_nom; + + effacement_pile_systeme(s_etat_processus); + (*s_etat_processus).l_base_pile_systeme = + s_sauvegarde_pile; + (*s_etat_processus).niveau_courant = + sauvegarde_niveau_courant; + + free((*s_etat_processus).definitions_chainees); + (*s_etat_processus).niveau_recursivite--; + + (*s_etat_processus).definitions_chainees = + definitions_chainees_precedentes; + (*s_etat_processus).longueur_definitions_chainees = + sauvegarde_longueur_definitions_chainees; + + (*s_etat_processus).position_courante = + position_courante; + + liberation(s_etat_processus, s_objet); + + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + (*s_etat_processus).autorisation_nom_implicite = + variable_implicite; + (*s_etat_processus).recherche_type = registre_recherche_type; + (*s_etat_processus).mode_execution_programme = + registre_mode_execution_programme; + + if ((*s_etat_processus).erreur_scrutation == d_vrai) + { + nombre_lignes_a_supprimer = + (*s_etat_processus).hauteur_pile_operationnelle + - nombre_lignes_a_supprimer; + + for(i = 0; i < nombre_lignes_a_supprimer; i++) + { + if (depilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + &s_sous_objet) == d_erreur) + { + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + liberation(s_etat_processus, s_sous_objet); + } + + (*s_etat_processus).instruction_courante = tampon; + (*s_etat_processus).autorisation_evaluation_nom = + autorisation_evaluation_nom; + + effacement_pile_systeme(s_etat_processus); + (*s_etat_processus).l_base_pile_systeme = + s_sauvegarde_pile; + (*s_etat_processus).niveau_courant = + sauvegarde_niveau_courant; + + free((*s_etat_processus).definitions_chainees); + (*s_etat_processus).niveau_recursivite--; + + (*s_etat_processus).definitions_chainees = + definitions_chainees_precedentes; + (*s_etat_processus).longueur_definitions_chainees = + sauvegarde_longueur_definitions_chainees; + + (*s_etat_processus).position_courante = + position_courante; + + liberation(s_etat_processus, s_objet); + + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + (*s_etat_processus).instruction_courante = tampon; + (*s_etat_processus).autorisation_evaluation_nom = + autorisation_evaluation_nom; + + (*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile; + (*s_etat_processus).niveau_courant = + sauvegarde_niveau_courant; + + free((*s_etat_processus).definitions_chainees); + (*s_etat_processus).definitions_chainees = + definitions_chainees_precedentes; + (*s_etat_processus).longueur_definitions_chainees = + sauvegarde_longueur_definitions_chainees; + + (*s_etat_processus).niveau_recursivite--; + + (*s_etat_processus).position_courante = position_courante; + +/* +-- On relit la pile qui contient des sous-objets contenant les ----------------- +-- éléments du tableau --------------------------------------------------------- +*/ + + profondeur_finale = (*s_etat_processus) + .hauteur_pile_operationnelle; + + nombre_lignes = profondeur_finale - profondeur_initiale; + + // Il ne peut y avoir que deux lignes. + + if (nombre_lignes != 2) + { + (*s_etat_processus).traitement_interruptible = + registre_interruption; + (*s_etat_processus).erreur_execution = + d_ex_dimensions_invalides; + return; + } + + if ((element = malloc(sizeof(struct_record))) == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + if (depilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + &((*((struct_record *) element)).donnees)) + == d_erreur) + { + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + if (depilement(s_etat_processus, + &((*s_etat_processus).l_base_pile), + &((*((struct_record *) element)).noms)) + == d_erreur) + { + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + (*s_objet).type = REC; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + + // Vérification des types. + + if (((*(*((struct_record *) element)).donnees).type != TBL) + || ((*(*((struct_record *) element)).noms).type != TBL)) + { + (*s_objet).objet = element; + liberation(s_etat_processus, s_objet); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + + for(i = 0; i < (*((struct_tableau *) (*(*((struct_record *) + element)).noms).objet)).nombre_elements; i++) + { + if ((*(*((struct_tableau *) (*(*((struct_record *) element)) + .noms).objet)).elements[i]).type != CHN) + { + (*s_objet).objet = element; + liberation(s_etat_processus, s_objet); + + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + return; + } + } + + // Vérification des dimensions + + if ((*((struct_tableau *) (*(*((struct_record *) element)) + .donnees).objet)).nombre_elements != + (*((struct_tableau *) (*(*((struct_record *) element)) + .noms).objet)).nombre_elements) + { + (*s_objet).objet = element; + liberation(s_etat_processus, s_objet); + + (*s_etat_processus).erreur_execution = + d_ex_dimensions_invalides; + return; + } + + // Tri de l'enregistrement (tri bull) + + tri_acheve = d_faux; + + while(tri_acheve == d_faux) + { + tri_acheve = d_vrai; + + for(i = 0; i < (*((struct_tableau *) (*(*((struct_record *) + element)).noms).objet)).nombre_elements - 1; i++) + { + if (strcmp((unsigned char *) (*(*((struct_tableau *) + (*(*((struct_record *) element)).noms).objet)) + .elements[i]).objet, (unsigned char *) + (*(*((struct_tableau *) (*(*((struct_record *) + element)).noms).objet)).elements[i + 1]).objet) + > 0) + { + tri_acheve = d_faux; + + tampon = (unsigned char *) (*(*((struct_tableau *) + (*(*((struct_record *) element)).noms) + .objet)).elements[i + 1]).objet; + (*(*((struct_tableau *) (*(*((struct_record *) + element)).noms).objet)).elements[i + 1]) + .objet = (*(*((struct_tableau *) + (*(*((struct_record *) element)).noms) + .objet)).elements[i]).objet; + (*(*((struct_tableau *) (*(*((struct_record *) + element)).noms).objet)).elements[i]).objet = + tampon; + + s_objet_registre = (*((struct_tableau *) + (*(*((struct_record *) element)).donnees) + .objet)).elements[i + 1]; + (*((struct_tableau *) (*(*((struct_record *) + element)).donnees).objet)).elements[i + 1] = + (*((struct_tableau *) (*(*((struct_record *) + element)).donnees).objet)).elements[i]; + (*((struct_tableau *) (*(*((struct_record *) + element)).donnees).objet)).elements[i] = + s_objet_registre; + } + } + } + + // Vérification de l'unicité des noms + + for(i = 0; i < (*((struct_tableau *) (*(*((struct_record *) + element)).noms).objet)).nombre_elements - 1; i++) + { + if (strcmp((unsigned char *) (*(*((struct_tableau *) + (*(*((struct_record *) element)).noms).objet)) + .elements[i]).objet, (unsigned char *) + (*(*((struct_tableau *) (*(*((struct_record *) + element)).noms).objet)) .elements[i + 1]).objet) + == 0) + { + (*s_objet).objet = element; + liberation(s_etat_processus, s_objet); + + (*s_etat_processus).erreur_execution = + d_ex_argument_invalide; + return; + } + } + } + + break; + } + +/* +-------------------------------------------------------------------------------- Entier ou réel -------------------------------------------------------------------------------- */ @@ -3437,20 +3947,23 @@ recherche_type(struct_processus *s_etat_ while((*ptr) != d_code_fin_chaine) { - if ((isalnum((*ptr)) == 0) && - ((*ptr) != '_') && - ((*ptr) != '$')) + if (isalnum(*ptr) != 0) { - free(s_objet); + ptr++; + } + else if (((*ptr) == '_') || ((*ptr == '$'))) + { + ptr++; + } + else + { + liberation(s_etat_processus, s_objet); (*s_etat_processus).erreur_execution = d_ex_syntaxe; (*s_etat_processus).traitement_interruptible = registre_interruption; - return; } - - ptr++; } (*s_objet).type = NOM; @@ -3512,27 +4025,61 @@ recherche_type(struct_processus *s_etat_ } else { - (*s_objet).type = INT; + // Le format ressemble à un entier mais il peut y avoir + // un dépassement de capacité lors de la conversion. + // On convertit donc en entier et en réel. Si les + // deux conversions donnent le même résultat, on + // considère que la conversion en entier est bonne. Dans + // le cas contraire, on garde la conversion en réel. - element = (void *) ((integer8 *) malloc( - sizeof(integer8))); + integer8 conversion_entiere; + real8 conversion_reelle; - if (element == NULL) + if (sscanf((*s_etat_processus).instruction_courante, "%lld", + &conversion_entiere) != 1) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - (*s_etat_processus).traitement_interruptible = - registre_interruption; - return; + (*s_etat_processus).erreur_execution = d_ex_syntaxe; } - nombre_elements_convertis = sscanf( - (*s_etat_processus).instruction_courante, "%lld", - (integer8 *) element); + if (errno != ERANGE) + { + (*s_objet).type = INT; - if (nombre_elements_convertis != 1) + element = malloc(sizeof(integer8)); + + if (element == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + (*((integer8 *) element)) = conversion_entiere; + } + else { - (*s_etat_processus).erreur_execution = d_ex_syntaxe; + if (sscanf((*s_etat_processus).instruction_courante, + "%lg", &conversion_reelle) != 1) + { + (*s_etat_processus).erreur_execution = d_ex_syntaxe; + } + + (*s_objet).type = REL; + + element = malloc(sizeof(real8)); + + if (element == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_allocation_memoire; + (*s_etat_processus).traitement_interruptible = + registre_interruption; + return; + } + + (*((real8 *) element)) = conversion_reelle; } } }