--- rpl/src/sequenceur.c 2012/09/29 17:53:02 1.56 +++ rpl/src/sequenceur.c 2013/02/27 17:11:45 1.66 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.10 - Copyright (C) 1989-2012 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.13 + Copyright (C) 1989-2013 Dr. BERTRAND Joël This file is part of RPL/2. @@ -25,13 +25,13 @@ /* ================================================================================ - 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 ================================================================================ */ @@ -106,7 +106,7 @@ 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... -------------------------------------------------------------------------------- */ @@ -117,7 +117,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Recherche de l'instruction suivante dans les définitions chaînées + Recherche de l'instruction suivante dans les définitions chaînées -------------------------------------------------------------------------------- */ @@ -517,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. -------------------------------------------------------------------------------- */ @@ -527,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. -------------------------------------------------------------------------------- */ @@ -557,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. -------------------------------------------------------------------------------- */ @@ -572,7 +572,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - L'instruction est une variable partagée + L'instruction est une variable partagée -------------------------------------------------------------------------------- */ @@ -582,8 +582,8 @@ 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", + printf("[%d] Évaluation de la variable " + "partagée %s de type %d\n", (int) getpid(), (*s_etat_processus) .instruction_courante, (*(*(*s_etat_processus) @@ -604,30 +604,19 @@ sequenceur(struct_processus *s_etat_proc fflush(stdout); } - if (pthread_mutex_lock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) != 0) - { - (*s_etat_processus).erreur_systeme = - d_es_processus; - return(d_erreur); - } - if (recherche_variable_partagee(s_etat_processus, (*(*s_etat_processus) .pointeur_variable_courante).nom, (*(*s_etat_processus) .pointeur_variable_courante).variable_partagee, - 'P') == d_vrai) + 'P') != NULL) { // La variable existe. if ((s_objet = copie_objet(s_etat_processus, (*(*s_etat_processus) - .s_liste_variables_partagees) - .table[(*(*s_etat_processus) - .s_liste_variables_partagees) - .position_variable].objet, 'P')) - == NULL) + .pointeur_variable_partagee_courante) + .objet, 'P')) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -635,45 +624,32 @@ sequenceur(struct_processus *s_etat_proc } if (pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) - != 0) + .pointeur_variable_partagee_courante) + .mutex)) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; return(d_erreur); } - if (empilement(s_etat_processus, - &((*s_etat_processus).l_base_pile), - s_objet) == d_erreur) + if (evaluation(s_etat_processus, s_objet, 'E') + == d_erreur) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; + liberation(s_etat_processus, s_objet); return(d_erreur); } + + liberation(s_etat_processus, s_objet); } else { // La variable n'existe plus. - - (*s_etat_processus).erreur_systeme = d_es; - - if (pthread_mutex_unlock(&((*(*s_etat_processus) - .s_liste_variables_partagees).mutex)) - != 0) - { - (*s_etat_processus).erreur_systeme = - d_es_processus; - return(d_erreur); - } - - recherche_type(s_etat_processus); } } /* -------------------------------------------------------------------------------- - L'instruction est une variable automatique (évaluation lors de l'empilement). + L'instruction est une variable automatique (évaluation lors de l'empilement). -------------------------------------------------------------------------------- */ @@ -684,7 +660,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- 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. -------------------------------------------------------------------------------- */ @@ -694,8 +670,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); } @@ -761,7 +737,7 @@ sequenceur(struct_processus *s_etat_proc { if ((*s_etat_processus).langue == 'F') { - printf("[%d] Empilement de la variable " + printf("[%d] Évaluation de la variable " "%s de type %d\n", (int) getpid(), (*s_etat_processus) @@ -794,14 +770,14 @@ sequenceur(struct_processus *s_etat_proc return(d_erreur); } - if (empilement(s_etat_processus, - &((*s_etat_processus).l_base_pile), - s_objet) == d_erreur) + if (evaluation(s_etat_processus, s_objet, 'E') + == d_erreur) { - (*s_etat_processus).erreur_systeme = - d_es_allocation_memoire; + liberation(s_etat_processus, s_objet); return(d_erreur); } + + liberation(s_etat_processus, s_objet); } } else @@ -809,7 +785,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - L'instruction est une donnée à empiler. + L'instruction est une donnée à empiler. -------------------------------------------------------------------------------- */ @@ -837,10 +813,10 @@ sequenceur(struct_processus *s_etat_proc (*s_etat_processus).erreur_execution = d_ex_nom_implicite; - // Si le niveau de récursivité est non nul, on + // 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. + // recherche_type(). On retourne à cette + // dernière en indiquant une erreur. if ((*s_etat_processus).niveau_recursivite != 0) { @@ -852,7 +828,7 @@ sequenceur(struct_processus *s_etat_proc } } - // Le séquenceur est appelé depuis la routine d'évaluation + // Le séquenceur est appelé depuis la routine d'évaluation if ((*s_etat_processus).evaluation_forcee == 'Y') { @@ -877,7 +853,7 @@ sequenceur(struct_processus *s_etat_proc liberation(s_etat_processus, s_objet_evaluation); } - // Le séquenceur est appelé depuis la routine de + // Le séquenceur est appelé depuis la routine de // recherche de type else if ((*s_etat_processus).recherche_type == 'Y') @@ -1001,7 +977,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Traitement des arrêts simples + Traitement des arrêts simples -------------------------------------------------------------------------------- */ @@ -1039,7 +1015,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) || @@ -1095,7 +1071,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 -------------------------------------------------------------------------------- */ @@ -1174,7 +1150,7 @@ sequenceur(struct_processus *s_etat_proc if ((*(*s_etat_processus).pointeur_variable_courante) .objet == NULL) { - // Variable partagée + // Variable partagée } else if ((*(*(*s_etat_processus) .pointeur_variable_courante).objet).type == ADR) @@ -1221,8 +1197,8 @@ sequenceur(struct_processus *s_etat_proc } /* - * 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) || @@ -1244,8 +1220,9 @@ sequenceur(struct_processus *s_etat_proc analyse(s_etat_processus, NULL); } else if ((strcmp(instruction_majuscule, "FOR") == 0) - || (strcmp(instruction_majuscule, "START") - == 0)) + || (strcmp(instruction_majuscule, "FORALL") + == 0) || (strcmp(instruction_majuscule, + "START") == 0)) { empilement_pile_systeme(s_etat_processus); @@ -1295,12 +1272,14 @@ sequenceur(struct_processus *s_etat_proc .l_base_pile_systeme).type_cloture != 'L')) { /* - * Libération des compteurs de boucle. + * Libération des compteurs de boucle. */ - presence_compteur = ((*(*s_etat_processus) + presence_compteur = (((*(*s_etat_processus) + .l_base_pile_systeme).type_cloture + == 'F') || ((*(*s_etat_processus) .l_base_pile_systeme).type_cloture - == 'F') ? d_vrai : d_faux; + == 'A')) ? d_vrai : d_faux; if (((*(*s_etat_processus).l_base_pile_systeme) .type_cloture != 'S') && @@ -1328,7 +1307,7 @@ sequenceur(struct_processus *s_etat_proc (*s_etat_processus).niveau_courant--; - if (retrait_variable_par_niveau( + if (retrait_variables_par_niveau( s_etat_processus) == d_erreur) { return(d_erreur); @@ -1344,7 +1323,7 @@ sequenceur(struct_processus *s_etat_proc } else { - // Traitement spécifique pour la fin + // Traitement spécifique pour la fin // d'une section critique if ((*s_etat_processus).l_base_pile_systeme @@ -1459,7 +1438,7 @@ sequenceur(struct_processus *s_etat_proc /* -------------------------------------------------------------------------------- - Messages d'erreur à afficher le cas échéant + Messages d'erreur à afficher le cas échéant -------------------------------------------------------------------------------- */