[BACK]Return to sequenceur.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/sequenceur.c between versions 1.58 and 1.66

version 1.58, 2012/10/01 11:05:09 version 1.66, 2013/02/27 17:11:45
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.11    RPL/2 (R) version 4.1.13
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 25 Line 25
   
 /*  /*
 ================================================================================  ================================================================================
   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
 ================================================================================  ================================================================================
 */  */
   
Line 106  sequenceur(struct_processus *s_etat_proc Line 106  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...    On boucle tant qu'on n'a pas une bonne raison de sortir...
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 117  sequenceur(struct_processus *s_etat_proc Line 117  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
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 517  sequenceur(struct_processus *s_etat_proc Line 517  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Dans le cas où une instruction est retournée, celle-ci est évaluée. Dans le    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.    cas contraire, l'interprète renvoie un message d'erreur et s'interrompt.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 527  sequenceur(struct_processus *s_etat_proc Line 527  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Scrutation des mots clef du langage RPL/2 et exécution le cas échéant    Scrutation des mots clef du langage RPL/2 et exécution le cas échéant
   de l'action associée.    de l'action associée.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 557  sequenceur(struct_processus *s_etat_proc Line 557  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.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 572  sequenceur(struct_processus *s_etat_proc Line 572  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   L'instruction est une variable partagée    L'instruction est une variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 582  sequenceur(struct_processus *s_etat_proc Line 582  sequenceur(struct_processus *s_etat_proc
                         {                          {
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
                             {                              {
                                 printf("[%d] Empilement de la variable "                                  printf("[%d] Évaluation de la variable "
                                         "partagée %s de type %d\n",                                          "partagée %s de type %d\n",
                                         (int) getpid(), (*s_etat_processus)                                          (int) getpid(), (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*(*(*s_etat_processus)                                          (*(*(*s_etat_processus)
Line 604  sequenceur(struct_processus *s_etat_proc Line 604  sequenceur(struct_processus *s_etat_proc
                             fflush(stdout);                              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,                          if (recherche_variable_partagee(s_etat_processus,
                                 (*(*s_etat_processus)                                  (*(*s_etat_processus)
                                 .pointeur_variable_courante).nom,                                  .pointeur_variable_courante).nom,
                                 (*(*s_etat_processus)                                  (*(*s_etat_processus)
                                 .pointeur_variable_courante).variable_partagee,                                  .pointeur_variable_courante).variable_partagee,
                                 'P') == d_vrai)                                  'P') != NULL)
                         {                          {
                             // La variable existe.                              // La variable existe.
   
                             if ((s_objet = copie_objet(s_etat_processus,                              if ((s_objet = copie_objet(s_etat_processus,
                                     (*(*s_etat_processus)                                      (*(*s_etat_processus)
                                     .s_liste_variables_partagees)                                      .pointeur_variable_partagee_courante)
                                     .table[(*(*s_etat_processus)                                      .objet, 'P')) == NULL)
                                     .s_liste_variables_partagees)  
                                     .position_variable].objet, 'P'))  
                                     == NULL)  
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_allocation_memoire;                                          d_es_allocation_memoire;
Line 635  sequenceur(struct_processus *s_etat_proc Line 624  sequenceur(struct_processus *s_etat_proc
                             }                              }
   
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)                              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                     .s_liste_variables_partagees).mutex))                                      .pointeur_variable_partagee_courante)
                                     != 0)                                      .mutex)) != 0)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
                                 return(d_erreur);                                  return(d_erreur);
                             }                              }
   
                             if (empilement(s_etat_processus,                              if (evaluation(s_etat_processus, s_objet, 'E')
                                     &((*s_etat_processus).l_base_pile),                                      == d_erreur)
                                     s_objet) == d_erreur)  
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  liberation(s_etat_processus, s_objet);
                                         d_es_allocation_memoire;  
                                 return(d_erreur);                                  return(d_erreur);
                             }                              }
   
                               liberation(s_etat_processus, s_objet);
                         }                          }
                         else                          else
                         {                          {
                             // La variable n'existe plus.                              // 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).
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 684  sequenceur(struct_processus *s_etat_proc Line 660  sequenceur(struct_processus *s_etat_proc
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   L'instruction est une variable de type 'adresse' pointant sur une    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.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 694  sequenceur(struct_processus *s_etat_proc Line 670  sequenceur(struct_processus *s_etat_proc
                         {                          {
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
                             {                              {
                                 printf("[%d] Branchement à la"                                  printf("[%d] Branchement à la"
                                         " définition %s\n", (int) getpid(),                                          " définition %s\n", (int) getpid(),
                                         (*s_etat_processus)                                          (*s_etat_processus)
                                         .instruction_courante);                                          .instruction_courante);
                             }                              }
Line 761  sequenceur(struct_processus *s_etat_proc Line 737  sequenceur(struct_processus *s_etat_proc
                         {                          {
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
                             {                              {
                                 printf("[%d] Empilement de la variable "                                  printf("[%d] Évaluation de la variable "
                                         "%s de type %d\n",                                          "%s de type %d\n",
                                         (int) getpid(),                                          (int) getpid(),
                                         (*s_etat_processus)                                          (*s_etat_processus)
Line 794  sequenceur(struct_processus *s_etat_proc Line 770  sequenceur(struct_processus *s_etat_proc
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
                         if (empilement(s_etat_processus,                          if (evaluation(s_etat_processus, s_objet, 'E')
                                 &((*s_etat_processus).l_base_pile),                                  == d_erreur)
                                 s_objet) == d_erreur)  
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              liberation(s_etat_processus, s_objet);
                                     d_es_allocation_memoire;  
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
                           liberation(s_etat_processus, s_objet);
                     }                      }
                 }                  }
                 else                  else
Line 809  sequenceur(struct_processus *s_etat_proc Line 785  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   L'instruction est une donnée à empiler.    L'instruction est une donnée à empiler.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 837  sequenceur(struct_processus *s_etat_proc Line 813  sequenceur(struct_processus *s_etat_proc
                                 (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                         d_ex_nom_implicite;                                          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                                  // arrive ici depuis la fonction
                                 // recherche_type(). On retourne à cette                                  // recherche_type(). On retourne à cette
                                 // dernière en indiquant une erreur.                                  // dernière en indiquant une erreur.
   
                                 if ((*s_etat_processus).niveau_recursivite != 0)                                  if ((*s_etat_processus).niveau_recursivite != 0)
                                 {                                  {
Line 852  sequenceur(struct_processus *s_etat_proc Line 828  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')                      if ((*s_etat_processus).evaluation_forcee == 'Y')
                     {                      {
Line 877  sequenceur(struct_processus *s_etat_proc Line 853  sequenceur(struct_processus *s_etat_proc
                         liberation(s_etat_processus, s_objet_evaluation);                          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                      // recherche de type
   
                     else if ((*s_etat_processus).recherche_type == 'Y')                      else if ((*s_etat_processus).recherche_type == 'Y')
Line 1001  sequenceur(struct_processus *s_etat_proc Line 977  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Traitement des arrêts simples    Traitement des arrêts simples
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1039  sequenceur(struct_processus *s_etat_proc Line 1015  sequenceur(struct_processus *s_etat_proc
   
         /*          /*
          * On ne sort pas du debugger en cas d'une erreur sur un programme           * 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) ||          if ((((*s_etat_processus).erreur_execution != d_ex) ||
Line 1095  sequenceur(struct_processus *s_etat_proc Line 1071  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
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1174  sequenceur(struct_processus *s_etat_proc Line 1150  sequenceur(struct_processus *s_etat_proc
                         if ((*(*s_etat_processus).pointeur_variable_courante)                          if ((*(*s_etat_processus).pointeur_variable_courante)
                                 .objet == NULL)                                  .objet == NULL)
                         {                          {
                             // Variable partagée                              // Variable partagée
                         }                          }
                         else if ((*(*(*s_etat_processus)                          else if ((*(*(*s_etat_processus)
                                 .pointeur_variable_courante).objet).type == ADR)                                  .pointeur_variable_courante).objet).type == ADR)
Line 1221  sequenceur(struct_processus *s_etat_proc Line 1197  sequenceur(struct_processus *s_etat_proc
                         }                          }
   
                         /*                          /*
                          * Traitement de la pile système par les                           * Traitement de la pile système par les
                          * différentes instructions.                           * différentes instructions.
                          */                           */
   
                         if ((strcmp(instruction_majuscule, "IF") == 0) ||                          if ((strcmp(instruction_majuscule, "IF") == 0) ||
Line 1296  sequenceur(struct_processus *s_etat_proc Line 1272  sequenceur(struct_processus *s_etat_proc
                                     .l_base_pile_systeme).type_cloture != 'L'))                                      .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)
Line 1331  sequenceur(struct_processus *s_etat_proc Line 1307  sequenceur(struct_processus *s_etat_proc
   
                                     (*s_etat_processus).niveau_courant--;                                      (*s_etat_processus).niveau_courant--;
   
                                     if (retrait_variable_par_niveau(                                      if (retrait_variables_par_niveau(
                                             s_etat_processus) == d_erreur)                                              s_etat_processus) == d_erreur)
                                     {                                      {
                                         return(d_erreur);                                          return(d_erreur);
Line 1347  sequenceur(struct_processus *s_etat_proc Line 1323  sequenceur(struct_processus *s_etat_proc
                             }                              }
                             else                              else
                             {                              {
                                 // Traitement spécifique pour la fin                                  // Traitement spécifique pour la fin
                                 // d'une section critique                                  // d'une section critique
   
                                 if ((*s_etat_processus).l_base_pile_systeme                                  if ((*s_etat_processus).l_base_pile_systeme
Line 1462  sequenceur(struct_processus *s_etat_proc Line 1438  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Messages d'erreur à afficher le cas échéant    Messages d'erreur à afficher le cas échéant
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Removed from v.1.58  
changed lines
  Added in v.1.66

CVSweb interface <joel.bertrand@systella.fr>