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

Diff for /rpl/src/sequenceur.c between versions 1.37 and 1.75

version 1.37, 2011/06/23 12:41:15 version 1.75, 2013/06/21 14:15:57
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.3    RPL/2 (R) version 4.1.15
   Copyright (C) 1989-2011 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 29 Line 29
 ================================================================================  ================================================================================
   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 44  sequenceur(struct_processus *s_etat_proc Line 44  sequenceur(struct_processus *s_etat_proc
     struct_objet                *s_objet_evaluation;      struct_objet                *s_objet_evaluation;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
   
       integer8                    niveau;
       integer8                    position_courante;
   
     logical1                    drapeau_appel_definition;      logical1                    drapeau_appel_definition;
     logical1                    drapeau_fin;      logical1                    drapeau_fin;
     logical1                    drapeau_then;      logical1                    drapeau_then;
     logical1                    erreur;      logical1                    erreur;
       logical1                    presence_compteur;
   
     static logical1             completion_valide = d_faux;      static logical1             completion_valide = d_faux;
   
Line 60  sequenceur(struct_processus *s_etat_proc Line 64  sequenceur(struct_processus *s_etat_proc
     unsigned char               *message;      unsigned char               *message;
     unsigned char               *registre;      unsigned char               *registre;
     unsigned char               *tampon;      unsigned char               *tampon;
     unsigned char               tampon_retour;  
     unsigned char               *t_ligne;      unsigned char               *t_ligne;
   
     unsigned long               i;      Keymap                      ancien_keymap;
     unsigned long               j;      Keymap                      nouveau_keymap;
     unsigned long               niveau;  
     unsigned long               position_courante;  
   
     (*s_etat_processus).retour_routine_evaluation = 'N';      (*s_etat_processus).retour_routine_evaluation = 'N';
   
Line 78  sequenceur(struct_processus *s_etat_proc Line 79  sequenceur(struct_processus *s_etat_proc
         {          {
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
                 printf("[%d] Exécution récursive de niveau %lu\n",                  printf("[%d] Exécution récursive de niveau %lld\n",
                         (int) getpid(), (*s_etat_processus).niveau_recursivite);                          (int) getpid(), (*s_etat_processus).niveau_recursivite);
             }              }
             else              else
             {              {
                 printf("[%d] %lu level recursive execution\n",                  printf("[%d] %lld level recursive execution\n",
                         (int) getpid(), (*s_etat_processus).niveau_recursivite);                          (int) getpid(), (*s_etat_processus).niveau_recursivite);
             }              }
         }          }
Line 109  sequenceur(struct_processus *s_etat_proc Line 110  sequenceur(struct_processus *s_etat_proc
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
     i = 0;  
     j = 0;  
   
     do      do
     {      {
         drapeau_appel_definition = d_faux;          drapeau_appel_definition = d_faux;
Line 182  sequenceur(struct_processus *s_etat_proc Line 180  sequenceur(struct_processus *s_etat_proc
                 flockfile(stdin);                  flockfile(stdin);
                 flockfile(stdout);                  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> ");                  ligne = readline("RPL/2> ");
   
                   rl_set_keymap(ancien_keymap);
                   rl_free(nouveau_keymap);
   
                 funlockfile(stdin);                  funlockfile(stdin);
                 funlockfile(stdout);                  funlockfile(stdout);
   
Line 323  sequenceur(struct_processus *s_etat_proc Line 333  sequenceur(struct_processus *s_etat_proc
                     }                      }
                     else                      else
                     {                      {
                         tampon_retour = (*(*s_etat_processus)                          empilement_pile_systeme(s_etat_processus);
                                 .l_base_pile_systeme).retour_definition;  
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               return(d_erreur);
                           }
   
                         (*(*s_etat_processus).l_base_pile_systeme)                          (*(*s_etat_processus).l_base_pile_systeme)
                                 .retour_definition = 'Y';                                  .retour_definition = 'Y';
   
Line 345  sequenceur(struct_processus *s_etat_proc Line 360  sequenceur(struct_processus *s_etat_proc
                                 printf("+++Error : Too few arguments\n");                                  printf("+++Error : Too few arguments\n");
                             }                              }
   
                             (*(*s_etat_processus).l_base_pile_systeme)                              depilement_pile_systeme(s_etat_processus);
                                     .retour_definition = tampon_retour;  
                               if ((*s_etat_processus).erreur_systeme != d_es)
                               {
                                   return(d_erreur);
                               }
   
                             fflush(stdout);                              fflush(stdout);
                         }                          }
                         else if (evaluation(s_etat_processus, s_objet, 'I') ==                          else if (evaluation(s_etat_processus, s_objet, 'I') ==
                                 d_erreur)                                  d_erreur)
                         {                          {
                             (*(*s_etat_processus).l_base_pile_systeme)  
                                     .retour_definition = tampon_retour;  
   
                             if ((*s_etat_processus).erreur_systeme != d_es)                              if ((*s_etat_processus).erreur_systeme != d_es)
                             {                              {
                                 if (test_cfsf(s_etat_processus, 51) == d_faux)                                  if (test_cfsf(s_etat_processus, 51) == d_faux)
Line 440  sequenceur(struct_processus *s_etat_proc Line 456  sequenceur(struct_processus *s_etat_proc
                         {                             {   
                             liberation(s_etat_processus, s_objet);                              liberation(s_etat_processus, s_objet);
                         }                          }
   
                         (*(*s_etat_processus).l_base_pile_systeme)  
                                 .retour_definition = tampon_retour;  
                     }                      }
                 }                  }
                 else if ((*s_etat_processus).invalidation_message_erreur                  else if ((*s_etat_processus).invalidation_message_erreur
Line 571  sequenceur(struct_processus *s_etat_proc Line 584  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,
Line 582  sequenceur(struct_processus *s_etat_proc Line 595  sequenceur(struct_processus *s_etat_proc
                             else                              else
                             {                              {
                                 printf("[%d] Pushing %s as %d type shared "                                  printf("[%d] Pushing %s as %d type shared "
                                         "variable \n", (int) getpid(),                                          "variable\n", (int) getpid(),
                                         (*s_etat_processus)                                          (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*(*(*s_etat_processus)                                          (*(*(*s_etat_processus)
Line 593  sequenceur(struct_processus *s_etat_proc Line 606  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 624  sequenceur(struct_processus *s_etat_proc Line 626  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);  
                         }                          }
                     }                      }
   
Line 734  sequenceur(struct_processus *s_etat_proc Line 723  sequenceur(struct_processus *s_etat_proc
                                     .niveau_courant;                                      .niveau_courant;
   
                             (*s_etat_processus).position_courante =                              (*s_etat_processus).position_courante =
                                     (*((unsigned long *)                                      (*((integer8 *)
                                     ((*(*(*s_etat_processus)                                      ((*(*(*s_etat_processus)
                                     .pointeur_variable_courante)                                      .pointeur_variable_courante)
                                     .objet).objet)));                                      .objet).objet)));
Line 750  sequenceur(struct_processus *s_etat_proc Line 739  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 783  sequenceur(struct_processus *s_etat_proc Line 772  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 964  sequenceur(struct_processus *s_etat_proc Line 953  sequenceur(struct_processus *s_etat_proc
                 free(instruction_majuscule);                  free(instruction_majuscule);
             }              }
   
             erreur |= (((*s_etat_processus).erreur_execution != d_ex)              erreur = (logical1) (erreur | (((*s_etat_processus)
                     ? d_erreur : d_absence_erreur);                      .erreur_execution != d_ex) ? d_erreur : d_absence_erreur));
         }          }
         else          else
         {          {
Line 1078  sequenceur(struct_processus *s_etat_proc Line 1067  sequenceur(struct_processus *s_etat_proc
             (*s_etat_processus).exception = d_ep;              (*s_etat_processus).exception = d_ep;
             erreur = d_absence_erreur;              erreur = d_absence_erreur;
   
             (*s_etat_processus).position_courante -=              (*s_etat_processus).position_courante -= (integer8)
                     strlen((*s_etat_processus).instruction_courante);                      strlen((*s_etat_processus).instruction_courante);
         }          }
   
Line 1188  sequenceur(struct_processus *s_etat_proc Line 1177  sequenceur(struct_processus *s_etat_proc
                                     .niveau_courant;                                      .niveau_courant;
   
                             (*s_etat_processus).position_courante =                              (*s_etat_processus).position_courante =
                                     (*((unsigned long *)                                      (*((integer8 *)
                                     ((*(*(*s_etat_processus)                                      ((*(*(*s_etat_processus)
                                     .pointeur_variable_courante)                                      .pointeur_variable_courante)
                                     .objet).objet)));                                      .objet).objet)));
Line 1219  sequenceur(struct_processus *s_etat_proc Line 1208  sequenceur(struct_processus *s_etat_proc
                                 (strcmp(instruction_majuscule, "DO") == 0) ||                                  (strcmp(instruction_majuscule, "DO") == 0) ||
                                 (strcmp(instruction_majuscule, "WHILE") == 0) ||                                  (strcmp(instruction_majuscule, "WHILE") == 0) ||
                                 (strcmp(instruction_majuscule, "FOR") == 0) ||                                  (strcmp(instruction_majuscule, "FOR") == 0) ||
                                   (strcmp(instruction_majuscule, "FORALL") == 0)
                                   ||
                                 (strcmp(instruction_majuscule, "START") == 0) ||                                  (strcmp(instruction_majuscule, "START") == 0) ||
                                 (strcmp(instruction_majuscule, "SELECT") == 0)                                  (strcmp(instruction_majuscule, "SELECT") == 0)
                                   ||
                                   (strcmp(instruction_majuscule, "CRITICAL") == 0)
                                 || (strcmp(instruction_majuscule, "CASE") == 0)                                  || (strcmp(instruction_majuscule, "CASE") == 0)
                                 || (strcmp(instruction_majuscule, "<<") == 0))                                  || (strcmp(instruction_majuscule, "<<") == 0))
                         {                          {
Line 1228  sequenceur(struct_processus *s_etat_proc Line 1221  sequenceur(struct_processus *s_etat_proc
                             {                              {
                                 analyse(s_etat_processus, NULL);                                  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                              else
                             {                              {
                                 empilement_pile_systeme(s_etat_processus);                                  empilement_pile_systeme(s_etat_processus);
Line 1260  sequenceur(struct_processus *s_etat_proc Line 1268  sequenceur(struct_processus *s_etat_proc
                                     return(d_absence_erreur);                                      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_variables_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                              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);                                  depilement_pile_systeme(s_etat_processus);
   
                                 if ((*s_etat_processus).erreur_systeme != d_es)                                  if ((*s_etat_processus).erreur_systeme != d_es)
Line 1302  sequenceur(struct_processus *s_etat_proc Line 1390  sequenceur(struct_processus *s_etat_proc
                             (strcmp(instruction_majuscule, "DO") == 0) ||                              (strcmp(instruction_majuscule, "DO") == 0) ||
                             (strcmp(instruction_majuscule, "WHILE") == 0) ||                              (strcmp(instruction_majuscule, "WHILE") == 0) ||
                             (strcmp(instruction_majuscule, "FOR") == 0) ||                              (strcmp(instruction_majuscule, "FOR") == 0) ||
                               (strcmp(instruction_majuscule, "FORALL") == 0) ||
                             (strcmp(instruction_majuscule, "START") == 0) ||                              (strcmp(instruction_majuscule, "START") == 0) ||
                             (strcmp(instruction_majuscule, "SELECT") == 0)                              (strcmp(instruction_majuscule, "SELECT") == 0)
                               || (strcmp(instruction_majuscule, "CRITICAL") == 0)
                             || (strcmp(instruction_majuscule, "CASE") == 0)                              || (strcmp(instruction_majuscule, "CASE") == 0)
                             || (strcmp(instruction_majuscule, "<<") == 0))                              || (strcmp(instruction_majuscule, "<<") == 0))
                     {                      {
Line 1398  sequenceur(struct_processus *s_etat_proc Line 1488  sequenceur(struct_processus *s_etat_proc
   
         if ((*s_etat_processus).var_volatile_processus_pere == 0)          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          else
         {          {
Removed from v.1.37  
changed lines
  Added in v.1.75

CVSweb interface <joel.bertrand@systella.fr>