--- rpl/src/sequenceur.c 2010/03/04 10:17:55 1.7 +++ rpl/src/sequenceur.c 2012/09/30 20:46:46 1.57 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.12 - Copyright (C) 1989-2010 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.10 + Copyright (C) 1989-2012 Dr. BERTRAND Joël This file is part of RPL/2. @@ -20,18 +20,18 @@ */ -#include "rpl.conv.h" +#include "rpl-conv.h" /* ================================================================================ - Boucle principale de l'interprète RPL/2 + Boucle principale de l'interprète RPL/2 ================================================================================ - Entrées : structure sur l'état du processus + Entrées : structure sur l'état du processus -------------------------------------------------------------------------------- - Sorties : Néant + Sorties : Néant -------------------------------------------------------------------------------- - Effets de bord : néant + Effets de bord : néant ================================================================================ */ @@ -48,6 +48,7 @@ sequenceur(struct_processus *s_etat_proc logical1 drapeau_fin; logical1 drapeau_then; logical1 erreur; + logical1 presence_compteur; static logical1 completion_valide = d_faux; @@ -63,11 +64,12 @@ sequenceur(struct_processus *s_etat_proc unsigned char tampon_retour; unsigned char *t_ligne; - unsigned long i; - unsigned long j; unsigned long niveau; unsigned long position_courante; + Keymap ancien_keymap; + Keymap nouveau_keymap; + (*s_etat_processus).retour_routine_evaluation = 'N'; if ((*s_etat_processus).debug == d_vrai) @@ -78,7 +80,7 @@ sequenceur(struct_processus *s_etat_proc { if ((*s_etat_processus).langue == 'F') { - printf("[%d] Exécution récursive de niveau %lu\n", + printf("[%d] Exécution récursive de niveau %lu\n", (int) getpid(), (*s_etat_processus).niveau_recursivite); } else @@ -91,7 +93,7 @@ sequenceur(struct_processus *s_etat_proc { if ((*s_etat_processus).langue == 'F') { - printf("[%d] Exécution\n", (int) getpid()); + printf("[%d] Exécution\n", (int) getpid()); } else { @@ -104,21 +106,18 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Boucle de l'interprète RPL/2 + Boucle de l'interprète RPL/2 On boucle tant qu'on n'a pas une bonne raison de sortir... -------------------------------------------------------------------------------- */ - i = 0; - j = 0; - do { drapeau_appel_definition = d_faux; /* -------------------------------------------------------------------------------- - Recherche de l'instruction suivante dans les définitions chaînées + Recherche de l'instruction suivante dans les définitions chaînées -------------------------------------------------------------------------------- */ @@ -182,8 +181,20 @@ sequenceur(struct_processus *s_etat_proc flockfile(stdin); flockfile(stdout); + ancien_keymap = rl_get_keymap(); + nouveau_keymap = rl_copy_keymap(ancien_keymap); + rl_set_keymap(nouveau_keymap); + + rl_bind_key(NEWLINE, readline_analyse_syntaxique); + rl_bind_key(RETURN, readline_analyse_syntaxique); + rl_bind_key(CTRL('g'), readline_effacement); + rl_done = 0; + ligne = readline("RPL/2> "); + rl_set_keymap(ancien_keymap); + rl_free(nouveau_keymap); + funlockfile(stdin); funlockfile(stdout); @@ -199,6 +210,7 @@ sequenceur(struct_processus *s_etat_proc (*s_etat_processus).localisation, d_locale)) == NULL) { + free((*s_etat_processus).instruction_courante); return(d_erreur); } @@ -305,6 +317,7 @@ sequenceur(struct_processus *s_etat_proc if ((message = messages(s_etat_processus)) == NULL) { + free((*s_etat_processus).instruction_courante); return(d_erreur); } @@ -336,7 +349,7 @@ sequenceur(struct_processus *s_etat_proc if ((*s_etat_processus).langue == 'F') { - printf("+++Erreur : Défaut d'argument\n"); + printf("+++Erreur : Défaut d'argument\n"); } else { @@ -364,12 +377,15 @@ sequenceur(struct_processus *s_etat_proc if ((message = messages(s_etat_processus)) == NULL) { + free((*s_etat_processus) + .instruction_courante); return(d_erreur); } printf("%s [%d]\n", message, (int) getpid()); - free(message); + free(message); + free((*s_etat_processus).instruction_courante); return(d_erreur); } else if ((*s_etat_processus) @@ -387,6 +403,8 @@ sequenceur(struct_processus *s_etat_proc if ((message = messages(s_etat_processus)) == NULL) { + free((*s_etat_processus) + .instruction_courante); return(d_erreur); } @@ -452,6 +470,7 @@ sequenceur(struct_processus *s_etat_proc if ((message = messages(s_etat_processus)) == NULL) { + free((*s_etat_processus).instruction_courante); free(ligne); return(d_erreur); } @@ -498,8 +517,8 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Dans le cas où une instruction est retournée, celle-ci est évaluée. Dans le - cas contraire, l'interprète renvoie un message d'erreur et s'interrompt. + Dans le cas où une instruction est retournée, celle-ci est évaluée. Dans le + cas contraire, l'interprète renvoie un message d'erreur et s'interrompt. -------------------------------------------------------------------------------- */ @@ -508,8 +527,8 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Scrutation des mots clef du langage RPL/2 et exécution le cas échéant - de l'action associée. + Scrutation des mots clef du langage RPL/2 et exécution le cas échéant + de l'action associée. -------------------------------------------------------------------------------- */ @@ -538,7 +557,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - L'instruction ne correspond pas à l'un des mots clef du langage RPL/2. + L'instruction ne correspond pas à l'un des mots clef du langage RPL/2. -------------------------------------------------------------------------------- */ @@ -547,14 +566,13 @@ sequenceur(struct_processus *s_etat_proc d_vrai) && ((*s_etat_processus) .autorisation_evaluation_nom == 'Y')) { - if (((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet == NULL) + if ((*(*s_etat_processus).pointeur_variable_courante) + .objet == NULL) { /* -------------------------------------------------------------------------------- - L'instruction est une variable partagée + L'instruction est une variable partagée -------------------------------------------------------------------------------- */ @@ -565,13 +583,11 @@ sequenceur(struct_processus *s_etat_proc if ((*s_etat_processus).langue == 'F') { printf("[%d] Empilement de la variable " - "partagée %s de type %d\n", - (int) getpid(), - (*s_etat_processus) + "partagée %s de type %d\n", + (int) getpid(), (*s_etat_processus) .instruction_courante, - (*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet) + (*(*(*s_etat_processus) + .pointeur_variable_courante).objet) .type); } else @@ -580,9 +596,8 @@ sequenceur(struct_processus *s_etat_proc "variable \n", (int) getpid(), (*s_etat_processus) .instruction_courante, - (*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet) + (*(*(*s_etat_processus) + .pointeur_variable_courante).objet) .type); } @@ -598,13 +613,11 @@ sequenceur(struct_processus *s_etat_proc } if (recherche_variable_partagee(s_etat_processus, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).nom, - ((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]) - .variable_partagee, 'P') == d_vrai) + (*(*s_etat_processus) + .pointeur_variable_courante).nom, + (*(*s_etat_processus) + .pointeur_variable_courante).variable_partagee, + 'P') == d_vrai) { // La variable existe. @@ -660,19 +673,18 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - L'instruction est une variable automatique (évaluation lors de l'empilement). + L'instruction est une variable automatique (évaluation lors de l'empilement). -------------------------------------------------------------------------------- */ - else if ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus).position_variable_courante]) + else if ((*(*(*s_etat_processus).pointeur_variable_courante) .objet).type == ADR) { /* -------------------------------------------------------------------------------- L'instruction est une variable de type 'adresse' pointant sur une - définition. Un branchement est effectué à cette adresse. + définition. Un branchement est effectué à cette adresse. -------------------------------------------------------------------------------- */ @@ -682,8 +694,8 @@ sequenceur(struct_processus *s_etat_proc { if ((*s_etat_processus).langue == 'F') { - printf("[%d] Branchement à la" - " définition %s\n", (int) getpid(), + printf("[%d] Branchement à la" + " définition %s\n", (int) getpid(), (*s_etat_processus) .instruction_courante); } @@ -734,10 +746,9 @@ sequenceur(struct_processus *s_etat_proc (*s_etat_processus).position_courante = (*((unsigned long *) - ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante] - .objet)).objet))); + ((*(*(*s_etat_processus) + .pointeur_variable_courante) + .objet).objet))); drapeau_appel_definition = d_vrai; } @@ -755,9 +766,8 @@ sequenceur(struct_processus *s_etat_proc (int) getpid(), (*s_etat_processus) .instruction_courante, - (*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet) + (*(*(*s_etat_processus) + .pointeur_variable_courante).objet) .type); } else @@ -766,9 +776,8 @@ sequenceur(struct_processus *s_etat_proc "\n", (int) getpid(), (*s_etat_processus) .instruction_courante, - (*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet) + (*(*(*s_etat_processus) + .pointeur_variable_courante).objet) .type); } @@ -776,9 +785,8 @@ sequenceur(struct_processus *s_etat_proc } if ((s_objet = copie_objet(s_etat_processus, - ((*s_etat_processus) - .s_liste_variables[(*s_etat_processus) - .position_variable_courante]).objet, 'P')) + (*(*s_etat_processus) + .pointeur_variable_courante).objet, 'P')) == NULL) { (*s_etat_processus).erreur_systeme = @@ -801,14 +809,50 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - L'instruction est une donnée à empiler. + L'instruction est une donnée à empiler. -------------------------------------------------------------------------------- */ (*s_etat_processus).erreur_systeme = d_es; recherche_type(s_etat_processus); - // Le séquenceur est appelé depuis la routine d'évaluation + if ((*s_etat_processus).autorisation_nom_implicite == 'N') + { + if ((*s_etat_processus).l_base_pile == NULL) + { + if ((*s_etat_processus).erreur_execution != + d_ex_nom_implicite) + { + (*s_etat_processus).erreur_execution = + d_ex_manque_argument; + } + } + else if ((*(*(*s_etat_processus).l_base_pile).donnee) + .type == NOM) + { + if ((*((struct_nom *) (*(*(*s_etat_processus) + .l_base_pile).donnee).objet)).symbole + == d_faux) + { + (*s_etat_processus).erreur_execution = + d_ex_nom_implicite; + + // Si le niveau de récursivité est non nul, on + // arrive ici depuis la fonction + // recherche_type(). On retourne à cette + // dernière en indiquant une erreur. + + if ((*s_etat_processus).niveau_recursivite != 0) + { + free((*s_etat_processus) + .instruction_courante); + return(d_erreur); + } + } + } + } + + // Le séquenceur est appelé depuis la routine d'évaluation if ((*s_etat_processus).evaluation_forcee == 'Y') { @@ -816,6 +860,7 @@ sequenceur(struct_processus *s_etat_proc &((*s_etat_processus).l_base_pile), &s_objet_evaluation) == d_erreur) { + free((*s_etat_processus).instruction_courante); (*s_etat_processus).erreur_execution = d_ex_manque_argument; return(d_erreur); @@ -824,12 +869,25 @@ sequenceur(struct_processus *s_etat_proc if (evaluation(s_etat_processus, s_objet_evaluation, 'N') == d_erreur) { + free((*s_etat_processus).instruction_courante); liberation(s_etat_processus, s_objet_evaluation); return(d_erreur); } liberation(s_etat_processus, s_objet_evaluation); } + + // Le séquenceur est appelé depuis la routine de + // recherche de type + + else if ((*s_etat_processus).recherche_type == 'Y') + { + if ((*s_etat_processus).erreur_execution != d_ex) + { + free((*s_etat_processus).instruction_courante); + return(d_erreur); + } + } } } else if (((*s_etat_processus).test_instruction == 'Y') && @@ -854,19 +912,7 @@ sequenceur(struct_processus *s_etat_proc != 0) && (strcmp((*s_etat_processus) .instruction_courante, ">>") != 0)) { - if ((s_objet = (struct_objet *) malloc( - sizeof(struct_objet))) == NULL) - { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; - return(d_erreur); - } - - initialisation_objet(s_objet); - (*s_objet).type = FCT; - - if (((*s_objet).objet = allocation(s_etat_processus, FCT)) - == NULL) + if ((s_objet = allocation(s_etat_processus, FCT)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -949,12 +995,13 @@ sequenceur(struct_processus *s_etat_proc fflush(stdout); + free((*s_etat_processus).instruction_courante); return(d_erreur); } /* -------------------------------------------------------------------------------- - Traitement des arrêts simples + Traitement des arrêts simples -------------------------------------------------------------------------------- */ @@ -970,7 +1017,7 @@ sequenceur(struct_processus *s_etat_proc { if (strncmp(getenv("LANG"), "fr", 2) == 0) { - printf("[%d] Arrêt\n", (int) getpid()); + printf("[%d] Arrêt\n", (int) getpid()); } else { @@ -992,7 +1039,7 @@ sequenceur(struct_processus *s_etat_proc /* * On ne sort pas du debugger en cas d'une erreur sur un programme - * en cours de débogage. + * en cours de débogage. */ if ((((*s_etat_processus).erreur_execution != d_ex) || @@ -1030,6 +1077,7 @@ sequenceur(struct_processus *s_etat_proc if ((message = messages(s_etat_processus)) == NULL) { + free((*s_etat_processus).instruction_courante); return(d_erreur); } @@ -1047,7 +1095,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Test de fin d'exécution du programme RPL/2 + Test de fin d'exécution du programme RPL/2 -------------------------------------------------------------------------------- */ @@ -1116,27 +1164,26 @@ sequenceur(struct_processus *s_etat_proc if (erreur == d_erreur) { + free((*s_etat_processus).instruction_courante); return(d_erreur); } if (recherche_variable(s_etat_processus, (*s_etat_processus).instruction_courante) == d_vrai) { - if (((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet == NULL) - { - // Variable partagée - } - else if ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante]).objet).type == - ADR) + if ((*(*s_etat_processus).pointeur_variable_courante) + .objet == NULL) + { + // Variable partagée + } + else if ((*(*(*s_etat_processus) + .pointeur_variable_courante).objet).type == ADR) { empilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) { + free((*s_etat_processus).instruction_courante); return(d_erreur); } @@ -1153,10 +1200,9 @@ sequenceur(struct_processus *s_etat_proc (*s_etat_processus).position_courante = (*((unsigned long *) - ((*((*s_etat_processus).s_liste_variables - [(*s_etat_processus) - .position_variable_courante] - .objet)).objet))); + ((*(*(*s_etat_processus) + .pointeur_variable_courante) + .objet).objet))); (*s_etat_processus) .autorisation_empilement_programme = 'N'; @@ -1170,12 +1216,13 @@ sequenceur(struct_processus *s_etat_proc if (instruction_majuscule == NULL) { + free((*s_etat_processus).instruction_courante); return(d_erreur); } /* - * Traitement de la pile système par les - * différentes instructions. + * Traitement de la pile système par les + * différentes instructions. */ if ((strcmp(instruction_majuscule, "IF") == 0) || @@ -1183,8 +1230,12 @@ sequenceur(struct_processus *s_etat_proc (strcmp(instruction_majuscule, "DO") == 0) || (strcmp(instruction_majuscule, "WHILE") == 0) || (strcmp(instruction_majuscule, "FOR") == 0) || + (strcmp(instruction_majuscule, "FORALL") == 0) + || (strcmp(instruction_majuscule, "START") == 0) || (strcmp(instruction_majuscule, "SELECT") == 0) + || + (strcmp(instruction_majuscule, "CRITICAL") == 0) || (strcmp(instruction_majuscule, "CASE") == 0) || (strcmp(instruction_majuscule, "<<") == 0)) { @@ -1192,6 +1243,21 @@ sequenceur(struct_processus *s_etat_proc { analyse(s_etat_processus, NULL); } + else if ((strcmp(instruction_majuscule, "FOR") == 0) + || (strcmp(instruction_majuscule, "FORALL") + == 0) || (strcmp(instruction_majuscule, + "START") == 0)) + { + empilement_pile_systeme(s_etat_processus); + + if ((*s_etat_processus).erreur_systeme != d_es) + { + return(d_erreur); + } + + (*(*s_etat_processus).l_base_pile_systeme) + .type_cloture = 'L'; + } else { empilement_pile_systeme(s_etat_processus); @@ -1224,8 +1290,88 @@ sequenceur(struct_processus *s_etat_proc return(d_absence_erreur); } } + else if (((strcmp(instruction_majuscule, "NEXT") + == 0) || (strcmp(instruction_majuscule, + "STEP") == 0)) && ((*(*s_etat_processus) + .l_base_pile_systeme).type_cloture != 'L')) + { + /* + * Libération des compteurs de boucle. + */ + + presence_compteur = (((*(*s_etat_processus) + .l_base_pile_systeme).type_cloture + == 'F') || ((*(*s_etat_processus) + .l_base_pile_systeme).type_cloture + == 'A')) ? d_vrai : d_faux; + + if (((*(*s_etat_processus).l_base_pile_systeme) + .type_cloture != 'S') && + (presence_compteur == d_faux)) + { + return(d_erreur); + } + + if (presence_compteur == d_vrai) + { + if (recherche_variable(s_etat_processus, + (*(*s_etat_processus) + .l_base_pile_systeme).nom_variable) + == d_faux) + { + return(d_erreur); + } + + if ((*(*s_etat_processus) + .pointeur_variable_courante).objet + == NULL) + { + return(d_erreur); + } + + (*s_etat_processus).niveau_courant--; + + if (retrait_variable_par_niveau( + s_etat_processus) == d_erreur) + { + return(d_erreur); + } + } + + depilement_pile_systeme(s_etat_processus); + + if ((*s_etat_processus).erreur_systeme != d_es) + { + return(d_erreur); + } + } else { + // Traitement spécifique pour la fin + // d'une section critique + + if ((*s_etat_processus).l_base_pile_systeme + == NULL) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return(d_erreur); + } + + if ((*(*s_etat_processus).l_base_pile_systeme) + .type_cloture == 'Q') + { + if (pthread_mutex_unlock( + &mutex_sections_critiques) != 0) + { + (*s_etat_processus).erreur_systeme = + d_es_processus; + return(d_erreur); + } + + (*s_etat_processus).sections_critiques--; + } + depilement_pile_systeme(s_etat_processus); if ((*s_etat_processus).erreur_systeme != d_es) @@ -1266,8 +1412,10 @@ sequenceur(struct_processus *s_etat_proc (strcmp(instruction_majuscule, "DO") == 0) || (strcmp(instruction_majuscule, "WHILE") == 0) || (strcmp(instruction_majuscule, "FOR") == 0) || + (strcmp(instruction_majuscule, "FORALL") == 0) || (strcmp(instruction_majuscule, "START") == 0) || (strcmp(instruction_majuscule, "SELECT") == 0) + || (strcmp(instruction_majuscule, "CRITICAL") == 0) || (strcmp(instruction_majuscule, "CASE") == 0) || (strcmp(instruction_majuscule, "<<") == 0)) { @@ -1314,7 +1462,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Messages d'erreur à afficher le cas échéant + Messages d'erreur à afficher le cas échéant -------------------------------------------------------------------------------- */ @@ -1362,7 +1510,8 @@ sequenceur(struct_processus *s_etat_proc if ((*s_etat_processus).var_volatile_processus_pere == 0) { - kill((*s_etat_processus).pid_processus_pere, SIGALRM); + envoi_signal_processus((*s_etat_processus).pid_processus_pere, + rpl_sigalrm); } else {