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

Diff for /rpl/src/sequenceur.c between versions 1.7 and 1.56

version 1.7, 2010/03/04 10:17:55 version 1.56, 2012/09/29 17:53:02
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.12    RPL/2 (R) version 4.1.10
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #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
 ================================================================================  ================================================================================
 */  */
   
Line 48  sequenceur(struct_processus *s_etat_proc Line 48  sequenceur(struct_processus *s_etat_proc
     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 63  sequenceur(struct_processus *s_etat_proc Line 64  sequenceur(struct_processus *s_etat_proc
     unsigned char               tampon_retour;      unsigned char               tampon_retour;
     unsigned char               *t_ligne;      unsigned char               *t_ligne;
   
     unsigned long               i;  
     unsigned long               j;  
     unsigned long               niveau;      unsigned long               niveau;
     unsigned long               position_courante;      unsigned long               position_courante;
   
       Keymap                      ancien_keymap;
       Keymap                      nouveau_keymap;
   
     (*s_etat_processus).retour_routine_evaluation = 'N';      (*s_etat_processus).retour_routine_evaluation = 'N';
   
     if ((*s_etat_processus).debug == d_vrai)      if ((*s_etat_processus).debug == d_vrai)
Line 78  sequenceur(struct_processus *s_etat_proc Line 80  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 %lu\n",
                         (int) getpid(), (*s_etat_processus).niveau_recursivite);                          (int) getpid(), (*s_etat_processus).niveau_recursivite);
             }              }
             else              else
Line 91  sequenceur(struct_processus *s_etat_proc Line 93  sequenceur(struct_processus *s_etat_proc
         {          {
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
                 printf("[%d] Exécution\n", (int) getpid());                  printf("[%d] Exécution\n", (int) getpid());
             }              }
             else              else
             {              {
Line 104  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...
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
     i = 0;  
     j = 0;  
   
     do      do
     {      {
         drapeau_appel_definition = d_faux;          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
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 182  sequenceur(struct_processus *s_etat_proc Line 181  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 199  sequenceur(struct_processus *s_etat_proc Line 210  sequenceur(struct_processus *s_etat_proc
                             (*s_etat_processus).localisation, d_locale))                              (*s_etat_processus).localisation, d_locale))
                             == NULL)                              == NULL)
                     {                      {
                           free((*s_etat_processus).instruction_courante);
                         return(d_erreur);                          return(d_erreur);
                     }                      }
   
Line 305  sequenceur(struct_processus *s_etat_proc Line 317  sequenceur(struct_processus *s_etat_proc
   
                         if ((message = messages(s_etat_processus)) == NULL)                          if ((message = messages(s_etat_processus)) == NULL)
                         {                          {
                               free((*s_etat_processus).instruction_courante);
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
Line 336  sequenceur(struct_processus *s_etat_proc Line 349  sequenceur(struct_processus *s_etat_proc
   
                             if ((*s_etat_processus).langue == 'F')                              if ((*s_etat_processus).langue == 'F')
                             {                              {
                                 printf("+++Erreur : Défaut d'argument\n");                                  printf("+++Erreur : Défaut d'argument\n");
                             }                              }
                             else                              else
                             {                              {
Line 364  sequenceur(struct_processus *s_etat_proc Line 377  sequenceur(struct_processus *s_etat_proc
                                 if ((message = messages(s_etat_processus))                                  if ((message = messages(s_etat_processus))
                                         == NULL)                                          == NULL)
                                 {                                  {
                                       free((*s_etat_processus)
                                               .instruction_courante);
                                     return(d_erreur);                                      return(d_erreur);
                                 }                                  }
   
                                 printf("%s [%d]\n", message, (int) getpid());                                  printf("%s [%d]\n", message, (int) getpid());
                                 free(message);  
   
                                   free(message);
                                   free((*s_etat_processus).instruction_courante);
                                 return(d_erreur);                                  return(d_erreur);
                             }                              }
                             else if ((*s_etat_processus)                              else if ((*s_etat_processus)
Line 387  sequenceur(struct_processus *s_etat_proc Line 403  sequenceur(struct_processus *s_etat_proc
                                 if ((message = messages(s_etat_processus))                                  if ((message = messages(s_etat_processus))
                                         == NULL)                                          == NULL)
                                 {                                  {
                                       free((*s_etat_processus)
                                               .instruction_courante);
                                     return(d_erreur);                                      return(d_erreur);
                                 }                                  }
   
Line 452  sequenceur(struct_processus *s_etat_proc Line 470  sequenceur(struct_processus *s_etat_proc
   
                     if ((message = messages(s_etat_processus)) == NULL)                      if ((message = messages(s_etat_processus)) == NULL)
                     {                      {
                           free((*s_etat_processus).instruction_courante);
                         free(ligne);                          free(ligne);
                         return(d_erreur);                          return(d_erreur);
                     }                      }
Line 498  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 508  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 538  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 547  sequenceur(struct_processus *s_etat_proc Line 566  sequenceur(struct_processus *s_etat_proc
                         d_vrai) && ((*s_etat_processus)                          d_vrai) && ((*s_etat_processus)
                         .autorisation_evaluation_nom == 'Y'))                          .autorisation_evaluation_nom == 'Y'))
                 {                  {
                     if (((*s_etat_processus).s_liste_variables                      if ((*(*s_etat_processus).pointeur_variable_courante)
                             [(*s_etat_processus)                              .objet == NULL)
                             .position_variable_courante]).objet == NULL)  
                     {                      {
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   L'instruction est une variable partagée    L'instruction est une variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 565  sequenceur(struct_processus *s_etat_proc Line 583  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] Empilement de la variable "
                                         "partagée %s de type %d\n",                                          "partagée %s de type %d\n",
                                         (int) getpid(),                                          (int) getpid(), (*s_etat_processus)
                                         (*s_etat_processus)  
                                         .instruction_courante,                                          .instruction_courante,
                                         (*((*s_etat_processus).s_liste_variables                                          (*(*(*s_etat_processus)
                                         [(*s_etat_processus)                                          .pointeur_variable_courante).objet)
                                         .position_variable_courante]).objet)  
                                         .type);                                          .type);
                             }                              }
                             else                              else
Line 580  sequenceur(struct_processus *s_etat_proc Line 596  sequenceur(struct_processus *s_etat_proc
                                         "variable \n", (int) getpid(),                                          "variable \n", (int) getpid(),
                                         (*s_etat_processus)                                          (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*((*s_etat_processus).s_liste_variables                                          (*(*(*s_etat_processus)
                                         [(*s_etat_processus)                                          .pointeur_variable_courante).objet)
                                         .position_variable_courante]).objet)  
                                         .type);                                          .type);
                             }                              }
   
Line 598  sequenceur(struct_processus *s_etat_proc Line 613  sequenceur(struct_processus *s_etat_proc
                         }                          }
   
                         if (recherche_variable_partagee(s_etat_processus,                          if (recherche_variable_partagee(s_etat_processus,
                                 ((*s_etat_processus).s_liste_variables                                  (*(*s_etat_processus)
                                 [(*s_etat_processus)                                  .pointeur_variable_courante).nom,
                                 .position_variable_courante]).nom,                                  (*(*s_etat_processus)
                                 ((*s_etat_processus).s_liste_variables                                  .pointeur_variable_courante).variable_partagee,
                                 [(*s_etat_processus)                                  'P') == d_vrai)
                                 .position_variable_courante])  
                                 .variable_partagee, 'P') == d_vrai)  
                         {                          {
                             // La variable existe.                              // La variable existe.
   
Line 660  sequenceur(struct_processus *s_etat_proc Line 673  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                      else if ((*(*(*s_etat_processus).pointeur_variable_courante)
                             [(*s_etat_processus).position_variable_courante])  
                             .objet).type == ADR)                              .objet).type == ADR)
                     {                      {
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   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 682  sequenceur(struct_processus *s_etat_proc Line 694  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 734  sequenceur(struct_processus *s_etat_proc Line 746  sequenceur(struct_processus *s_etat_proc
   
                             (*s_etat_processus).position_courante =                              (*s_etat_processus).position_courante =
                                     (*((unsigned long *)                                      (*((unsigned long *)
                                     ((*((*s_etat_processus).s_liste_variables                                      ((*(*(*s_etat_processus)
                                     [(*s_etat_processus)                                      .pointeur_variable_courante)
                                     .position_variable_courante]                                      .objet).objet)));
                                     .objet)).objet)));  
   
                             drapeau_appel_definition = d_vrai;                              drapeau_appel_definition = d_vrai;
                         }                          }
Line 755  sequenceur(struct_processus *s_etat_proc Line 766  sequenceur(struct_processus *s_etat_proc
                                         (int) getpid(),                                          (int) getpid(),
                                         (*s_etat_processus)                                          (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*((*s_etat_processus).s_liste_variables                                          (*(*(*s_etat_processus)
                                         [(*s_etat_processus)                                          .pointeur_variable_courante).objet)
                                         .position_variable_courante]).objet)  
                                         .type);                                          .type);
                             }                              }
                             else                              else
Line 766  sequenceur(struct_processus *s_etat_proc Line 776  sequenceur(struct_processus *s_etat_proc
                                         "\n", (int) getpid(),                                          "\n", (int) getpid(),
                                         (*s_etat_processus)                                          (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*((*s_etat_processus).s_liste_variables                                          (*(*(*s_etat_processus)
                                         [(*s_etat_processus)                                          .pointeur_variable_courante).objet)
                                         .position_variable_courante]).objet)  
                                         .type);                                          .type);
                             }                              }
   
Line 776  sequenceur(struct_processus *s_etat_proc Line 785  sequenceur(struct_processus *s_etat_proc
                         }                          }
   
                         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[(*s_etat_processus)                                  .pointeur_variable_courante).objet, 'P'))
                                 .position_variable_courante]).objet, 'P'))  
                                 == NULL)                                  == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 801  sequenceur(struct_processus *s_etat_proc Line 809  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;                      (*s_etat_processus).erreur_systeme = d_es;
                     recherche_type(s_etat_processus);                      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')                      if ((*s_etat_processus).evaluation_forcee == 'Y')
                     {                      {
Line 816  sequenceur(struct_processus *s_etat_proc Line 860  sequenceur(struct_processus *s_etat_proc
                                 &((*s_etat_processus).l_base_pile),                                  &((*s_etat_processus).l_base_pile),
                                 &s_objet_evaluation) == d_erreur)                                  &s_objet_evaluation) == d_erreur)
                         {                          {
                               free((*s_etat_processus).instruction_courante);
                             (*s_etat_processus).erreur_execution =                              (*s_etat_processus).erreur_execution =
                                     d_ex_manque_argument;                                      d_ex_manque_argument;
                             return(d_erreur);                              return(d_erreur);
Line 824  sequenceur(struct_processus *s_etat_proc Line 869  sequenceur(struct_processus *s_etat_proc
                         if (evaluation(s_etat_processus, s_objet_evaluation,                          if (evaluation(s_etat_processus, s_objet_evaluation,
                                 'N') == d_erreur)                                  'N') == d_erreur)
                         {                          {
                               free((*s_etat_processus).instruction_courante);
                             liberation(s_etat_processus, s_objet_evaluation);                              liberation(s_etat_processus, s_objet_evaluation);
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
                         liberation(s_etat_processus, s_objet_evaluation);                          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') &&              else if (((*s_etat_processus).test_instruction == 'Y') &&
Line 854  sequenceur(struct_processus *s_etat_proc Line 912  sequenceur(struct_processus *s_etat_proc
                         != 0) && (strcmp((*s_etat_processus)                          != 0) && (strcmp((*s_etat_processus)
                         .instruction_courante, ">>") != 0))                          .instruction_courante, ">>") != 0))
                 {                  {
                     if ((s_objet = (struct_objet *) malloc(                      if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
                             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)  
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_allocation_memoire;                                  d_es_allocation_memoire;
Line 949  sequenceur(struct_processus *s_etat_proc Line 995  sequenceur(struct_processus *s_etat_proc
   
             fflush(stdout);              fflush(stdout);
   
               free((*s_etat_processus).instruction_courante);
             return(d_erreur);              return(d_erreur);
         }          }
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Traitement des arrêts simples    Traitement des arrêts simples
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 970  sequenceur(struct_processus *s_etat_proc Line 1017  sequenceur(struct_processus *s_etat_proc
                 {                  {
                     if (strncmp(getenv("LANG"), "fr", 2) == 0)                      if (strncmp(getenv("LANG"), "fr", 2) == 0)
                     {                      {
                         printf("[%d] Arrêt\n", (int) getpid());                          printf("[%d] Arrêt\n", (int) getpid());
                     }                      }
                     else                      else
                     {                      {
Line 992  sequenceur(struct_processus *s_etat_proc Line 1039  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 1030  sequenceur(struct_processus *s_etat_proc Line 1077  sequenceur(struct_processus *s_etat_proc
   
             if ((message = messages(s_etat_processus)) == NULL)              if ((message = messages(s_etat_processus)) == NULL)
             {              {
                   free((*s_etat_processus).instruction_courante);
                 return(d_erreur);                  return(d_erreur);
             }              }
   
Line 1047  sequenceur(struct_processus *s_etat_proc Line 1095  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 1116  sequenceur(struct_processus *s_etat_proc Line 1164  sequenceur(struct_processus *s_etat_proc
   
                     if (erreur == d_erreur)                      if (erreur == d_erreur)
                     {                      {
                           free((*s_etat_processus).instruction_courante);
                         return(d_erreur);                          return(d_erreur);
                     }                      }
   
                     if (recherche_variable(s_etat_processus,                      if (recherche_variable(s_etat_processus,
                             (*s_etat_processus).instruction_courante) == d_vrai)                              (*s_etat_processus).instruction_courante) == d_vrai)
                     {                      {
                         if (((*s_etat_processus).s_liste_variables                          if ((*(*s_etat_processus).pointeur_variable_courante)
                                 [(*s_etat_processus)                                  .objet == NULL)
                                 .position_variable_courante]).objet == NULL)                          {
                         {                              // Variable partagée
                             // Variable partagée                          }
                         }                          else if ((*(*(*s_etat_processus)
                         else if ((*((*s_etat_processus).s_liste_variables                                  .pointeur_variable_courante).objet).type == ADR)
                                 [(*s_etat_processus)  
                                 .position_variable_courante]).objet).type ==  
                                 ADR)  
                         {                          {
                             empilement_pile_systeme(s_etat_processus);                              empilement_pile_systeme(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_systeme != d_es)                              if ((*s_etat_processus).erreur_systeme != d_es)
                             {                              {
                                   free((*s_etat_processus).instruction_courante);
                                 return(d_erreur);                                  return(d_erreur);
                             }                              }
   
Line 1153  sequenceur(struct_processus *s_etat_proc Line 1200  sequenceur(struct_processus *s_etat_proc
   
                             (*s_etat_processus).position_courante =                              (*s_etat_processus).position_courante =
                                     (*((unsigned long *)                                      (*((unsigned long *)
                                     ((*((*s_etat_processus).s_liste_variables                                      ((*(*(*s_etat_processus)
                                     [(*s_etat_processus)                                      .pointeur_variable_courante)
                                     .position_variable_courante]                                      .objet).objet)));
                                     .objet)).objet)));  
   
                             (*s_etat_processus)                              (*s_etat_processus)
                                     .autorisation_empilement_programme = 'N';                                      .autorisation_empilement_programme = 'N';
Line 1170  sequenceur(struct_processus *s_etat_proc Line 1216  sequenceur(struct_processus *s_etat_proc
   
                         if (instruction_majuscule == NULL)                          if (instruction_majuscule == NULL)
                         {                          {
                               free((*s_etat_processus).instruction_courante);
                             return(d_erreur);                              return(d_erreur);
                         }                          }
   
                         /*                          /*
                          * 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 1183  sequenceur(struct_processus *s_etat_proc Line 1230  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 1192  sequenceur(struct_processus *s_etat_proc Line 1243  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, "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 1224  sequenceur(struct_processus *s_etat_proc Line 1289  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') ? 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                              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 1266  sequenceur(struct_processus *s_etat_proc Line 1409  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 1314  sequenceur(struct_processus *s_etat_proc Line 1459  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Messages d'erreur à afficher le cas échéant    Messages d'erreur à afficher le cas échéant
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1362  sequenceur(struct_processus *s_etat_proc Line 1507  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.7  
changed lines
  Added in v.1.56

CVSweb interface <joel.bertrand@systella.fr>