--- rpl/src/instructions_r7.c 2015/01/05 13:12:39 1.26 +++ rpl/src/instructions_r7.c 2020/01/10 11:15:48 1.48 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.19 - Copyright (C) 1989-2015 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.32 + Copyright (C) 1989-2020 Dr. BERTRAND Joël This file is part of RPL/2. @@ -74,7 +74,7 @@ instruction_restart(struct_processus *s_ } envoi_signal_processus((*s_etat_processus).pid_processus_pere, - rpl_sigabort); + rpl_sigabort, d_faux); (*s_etat_processus).requete_arret = 'Y'; attente.tv_sec = 0; @@ -112,6 +112,8 @@ instruction_restart(struct_processus *s_ void instruction_regex(struct_processus *s_etat_processus) { + integer8 longueur; + regex_t expression; struct_liste_chainee *l_element_courant_ecriture; @@ -121,6 +123,8 @@ instruction_regex(struct_processus *s_et struct_objet *s_objet_argument_2; struct_objet *s_objet_resultat; + unsigned char *exp; + (*s_etat_processus).erreur_execution = d_ex; if ((*s_etat_processus).affichage_arguments == 'Y') @@ -181,7 +185,14 @@ instruction_regex(struct_processus *s_et { // Renvoie 0 ou -1 - if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet, + if ((exp = formateur_flux(s_etat_processus, (*s_objet_argument_1).objet, + &longueur)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (regcomp(&expression, (const char *) exp, REG_EXTENDED | REG_NOSUB) != 0) { liberation(s_etat_processus, s_objet_argument_1); @@ -208,13 +219,21 @@ instruction_regex(struct_processus *s_et } regfree(&expression); + free(exp); } else if (((*s_objet_argument_1).type == CHN) && ((*s_objet_argument_2).type == LST)) { // Renvoie une liste de chaînes qui correspondent - if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet, + if ((exp = formateur_flux(s_etat_processus, (*s_objet_argument_1).objet, + &longueur)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + if (regcomp(&expression, (const char *) exp, REG_EXTENDED | REG_NOSUB) != 0) { liberation(s_etat_processus, s_objet_argument_1); @@ -306,6 +325,7 @@ instruction_regex(struct_processus *s_et } regfree(&expression); + free(exp); } else { @@ -676,6 +696,189 @@ instruction_rgdr(struct_processus *s_eta if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), s_objet_resultat) == d_erreur) + { + return; + } + + return; +} + + +/* +================================================================================ + Fonction 'record' +================================================================================ + Entrées : pointeur sur une structure struct_processus +-------------------------------------------------------------------------------- + Sorties : +-------------------------------------------------------------------------------- + Effets de bord : néant +================================================================================ +*/ + +static int +fonction_comparaison(const void *argument_1, const void *argument_2) +{ + return(strcmp((unsigned char *) (**((struct_objet **) argument_1)).objet, + (unsigned char *) (**((struct_objet **) argument_2)).objet)); +} + + +void +instruction_record(struct_processus *s_etat_processus) +{ + integer8 i; + + struct_objet *s_objet_argument_1; + struct_objet *s_objet_argument_2; + struct_objet *s_objet_resultat; + + (*s_etat_processus).erreur_execution = d_ex; + + if ((*s_etat_processus).affichage_arguments == 'Y') + { + printf("\n RECORD "); + + if ((*s_etat_processus).langue == 'F') + { + printf("(création d'un enregistrement)\n\n"); + } + else + { + printf("(create record)\n\n"); + } + + printf(" 1: %s\n", d_TAB); + printf("-> 1: %s\n", d_REC); + + return; + } + else if ((*s_etat_processus).test_instruction == 'Y') + { + (*s_etat_processus).nombre_arguments = -1; + return; + } + + if (test_cfsf(s_etat_processus, 31) == d_vrai) + { + if (empilement_pile_last(s_etat_processus, 1) == d_erreur) + { + return; + } + } + + if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile), + &s_objet_argument_1) == d_erreur) + { + (*s_etat_processus).erreur_execution = d_ex_manque_argument; + return; + } + + if ((*s_objet_argument_1).type == TBL) + { + // Vérification des noms + + if ((*((struct_tableau *) (*s_objet_argument_1).objet)).nombre_elements + == 0) + { + (*s_etat_processus).erreur_execution = d_ex_nombre_arguments; + liberation(s_etat_processus, s_objet_argument_1); + return; + } + + for(i = 0; i < (*((struct_tableau *) (*s_objet_argument_1).objet)) + .nombre_elements; i++) + { + if ((*(*((struct_tableau *) (*s_objet_argument_1).objet)) + .elements[i]).type != CHN) + { + (*s_etat_processus).erreur_execution = + d_ex_erreur_type_argument; + + liberation(s_etat_processus, s_objet_argument_1); + return; + } + } + + // Tri de la table des noms + + qsort((*((struct_tableau *) (*s_objet_argument_1).objet)).elements, + (size_t) (*((struct_tableau *) (*s_objet_argument_1).objet)) + .nombre_elements, sizeof(struct_objet *), + fonction_comparaison); + + // Vérification de l'unicité des noms + + for(i = 0; i < (*((struct_tableau *) (*s_objet_argument_1).objet)) + .nombre_elements - 1; i++) + { + if (strcmp((unsigned char *) (*(*((struct_tableau *) + (*s_objet_argument_1).objet)).elements[i]).objet, + (unsigned char *) (*(*((struct_tableau *) + (*s_objet_argument_1).objet)).elements[i + 1]).objet) + == 0) + { + (*s_etat_processus).erreur_execution = + d_ex_argument_invalide; + + liberation(s_etat_processus, s_objet_argument_1); + return; + } + } + + // Allocation de la table des données + + if ((s_objet_argument_2 = allocation(s_etat_processus, TBL)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + (*((struct_tableau *) (*s_objet_argument_2).objet)).nombre_elements = + (*((struct_tableau *) (*s_objet_argument_1).objet)) + .nombre_elements; + + if (((*((struct_tableau *) (*s_objet_argument_2).objet)).elements = + malloc(((size_t) (*((struct_tableau *) + (*s_objet_argument_2).objet)).nombre_elements) * + sizeof(struct_objet *))) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + for(i = 0; i < (*((struct_tableau *) (*s_objet_argument_2).objet)) + .nombre_elements; i++) + + { + if (((*((struct_tableau *) (*s_objet_argument_2).objet)).elements[i] + = allocation(s_etat_processus, LST)) == NULL) + { + return; + } + } + + if ((s_objet_resultat = allocation(s_etat_processus, REC)) == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return; + } + + (*((struct_record *) (*s_objet_resultat).objet)).noms = + s_objet_argument_1; + (*((struct_record *) (*s_objet_resultat).objet)).donnees = + s_objet_argument_2; + } + else + { + liberation(s_etat_processus, s_objet_argument_1); + + (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument; + return; + } + + if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), + s_objet_resultat) == d_erreur) { return; }