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

Diff for /rpl/src/sequenceur.c between versions 1.59 and 1.105

version 1.59, 2012/10/04 15:21:26 version 1.105, 2019/02/03 14:41:30
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.11    RPL/2 (R) version 4.1.31
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2019 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 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;
Line 61  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               niveau;  
     unsigned long               position_courante;  
   
     Keymap                      ancien_keymap;      Keymap                      ancien_keymap;
     Keymap                      nouveau_keymap;      Keymap                      nouveau_keymap;
   
Line 80  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 93  sequenceur(struct_processus *s_etat_proc Line 92  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 106  sequenceur(struct_processus *s_etat_proc Line 105  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 116  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 198  sequenceur(struct_processus *s_etat_proc Line 197  sequenceur(struct_processus *s_etat_proc
                 funlockfile(stdin);                  funlockfile(stdin);
                 funlockfile(stdout);                  funlockfile(stdout);
   
                 if ((*s_etat_processus).var_volatile_requete_arret != 0)  
                 {  
                     (*s_etat_processus).requete_arret = 'Y';  
                     break;  
                 }  
   
                 if (ligne != NULL)                  if (ligne != NULL)
                 {                  {
                     if ((t_ligne = transliteration(s_etat_processus, ligne,                      if ((t_ligne = transliteration(s_etat_processus, ligne,
Line 217  sequenceur(struct_processus *s_etat_proc Line 210  sequenceur(struct_processus *s_etat_proc
                     free(ligne);                      free(ligne);
                     ligne = t_ligne;                      ligne = t_ligne;
   
                     if ((ligne = compactage(ligne)) == NULL)                      if ((ligne = compactage(s_etat_processus, ligne)) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_allocation_memoire;                                  d_es_allocation_memoire;
Line 266  sequenceur(struct_processus *s_etat_proc Line 259  sequenceur(struct_processus *s_etat_proc
                     sprintf(ligne, "dup");                      sprintf(ligne, "dup");
                 }                  }
   
                   if ((*s_etat_processus).var_volatile_requete_arret != 0)
                   {
                       free(ligne);
                       (*s_etat_processus).requete_arret = 'Y';
                       break;
                   }
   
                 add_history(ligne);                  add_history(ligne);
                 stifle_history(ds_longueur_historique);                  stifle_history(ds_longueur_historique);
   
Line 296  sequenceur(struct_processus *s_etat_proc Line 296  sequenceur(struct_processus *s_etat_proc
                     tampon = (*s_etat_processus).instruction_courante;                      tampon = (*s_etat_processus).instruction_courante;
                     (*s_etat_processus).instruction_courante = ligne;                      (*s_etat_processus).instruction_courante = ligne;
   
                       (*s_etat_processus).type_en_cours = NON;
                     recherche_type(s_etat_processus);                      recherche_type(s_etat_processus);
   
                     (*s_etat_processus).instruction_courante = tampon;                      (*s_etat_processus).instruction_courante = tampon;
Line 334  sequenceur(struct_processus *s_etat_proc Line 335  sequenceur(struct_processus *s_etat_proc
                     }                      }
                     else                      else
                     {                      {
                         tampon_retour = (*(*s_etat_processus)                          position_courante =
                                 .l_base_pile_systeme).retour_definition;                                  (*s_etat_processus).position_courante;
                           empilement_pile_systeme(s_etat_processus);
   
                           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 349  sequenceur(struct_processus *s_etat_proc Line 357  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
                             {                              {
                                 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 452  sequenceur(struct_processus *s_etat_proc Line 461  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)                          (*s_etat_processus).position_courante =
                                 .retour_definition = tampon_retour;                                  position_courante;
                     }                      }
                 }                  }
                 else if ((*s_etat_processus).invalidation_message_erreur                  else if ((*s_etat_processus).invalidation_message_erreur
Line 517  sequenceur(struct_processus *s_etat_proc Line 526  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 536  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.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               (*s_etat_processus).instruction_sensible = 'N';
   
             analyse(s_etat_processus, NULL);              analyse(s_etat_processus, NULL);
   
             if ((*s_etat_processus).traitement_cycle_exit != 'N')              if ((*s_etat_processus).traitement_cycle_exit != 'N')
Line 557  sequenceur(struct_processus *s_etat_proc Line 568  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 583  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   L'instruction est une variable partagée    L'instruction est une variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
                         if ((*s_etat_processus).debug == d_vrai)                          if (recherche_variable_partagee(s_etat_processus,
                             if (((*s_etat_processus).type_debug &                                  (*(*s_etat_processus)
                                     d_debug_variables) != 0)                                  .pointeur_variable_courante).nom,
                                   (*(*s_etat_processus)
                                   .pointeur_variable_courante).variable_partagee,
                                   'P') != NULL)
                         {                          {
                             if ((*s_etat_processus).langue == 'F')                              // La variable existe.
   
                               if ((*s_etat_processus).debug == d_vrai)
                                   if (((*s_etat_processus).type_debug &
                                           d_debug_variables) != 0)
                             {                              {
                                 printf("[%d] Empilement de la variable "                                  if ((*s_etat_processus).langue == 'F')
                                         "partagée %s de type %d\n",                                  {
                                       printf("[%d] Évaluation de la variable "
                                           "partagée %s de type %d\n",
                                         (int) getpid(), (*s_etat_processus)                                          (int) getpid(), (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*(*(*s_etat_processus)                                          (*(*(*s_etat_processus)
                                         .pointeur_variable_courante).objet)                                          .pointeur_variable_partagee_courante)
                                         .type);                                          .objet).type);
                             }                                  }
                             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)
                                         .pointeur_variable_courante).objet)                                          .pointeur_variable_partagee_courante)
                                         .type);                                          .objet).type);
                             }                                  }
   
                             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,                                  fflush(stdout);
                                 (*(*s_etat_processus)                              }
                                 .pointeur_variable_courante).nom,  
                                 (*(*s_etat_processus)  
                                 .pointeur_variable_courante).variable_partagee,  
                                 'P') == d_vrai)  
                         {  
                             // 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 635  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.
                               if ((*s_etat_processus).debug == d_vrai)
                             (*s_etat_processus).erreur_systeme = d_es;                                  if (((*s_etat_processus).type_debug &
                                           d_debug_variables) != 0)
                             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                     .s_liste_variables_partagees).mutex))  
                                     != 0)  
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  if ((*s_etat_processus).langue == 'F')
                                         d_es_processus;                                  {
                                 return(d_erreur);                                      printf("[%d] Tentative d'accès à la "
                             }                                          "variable partagée non définie %s\n",
                                           (int) getpid(), (*s_etat_processus)
                                           .instruction_courante);
                                   }
                                   else
                                   {
                                       printf("[%d] Trying to access to undefined "
                                           "shared variable %s\n",
                                           (int) getpid(),
                                           (*s_etat_processus)
                                           .instruction_courante);
                                   }
   
                             recherche_type(s_etat_processus);                                  fflush(stdout);
                               }
                         }                          }
                     }                      }
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   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 693  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 703  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 733  sequenceur(struct_processus *s_etat_proc Line 742  sequenceur(struct_processus *s_etat_proc
                                 }                                  }
                             }                              }
   
                               (*s_etat_processus).debug_programme = d_faux;
   
                             (*(*s_etat_processus).l_base_pile_systeme)                              (*(*s_etat_processus).l_base_pile_systeme)
                                     .adresse_retour = (*s_etat_processus)                                      .adresse_retour = (*s_etat_processus)
                                     .position_courante;                                      .position_courante;
Line 745  sequenceur(struct_processus *s_etat_proc Line 756  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 761  sequenceur(struct_processus *s_etat_proc Line 772  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 805  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 820  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;
                       (*s_etat_processus).type_en_cours = NON;
                     recherche_type(s_etat_processus);                      recherche_type(s_etat_processus);
   
                     if ((*s_etat_processus).autorisation_nom_implicite == 'N')                      if ((*s_etat_processus).autorisation_nom_implicite == 'N')
                     {                      {
                         if ((*s_etat_processus).l_base_pile == NULL)                          if ((*s_etat_processus).l_base_pile == NULL)
                         {                          {
                             if ((*s_etat_processus).erreur_execution !=                              if (((*s_etat_processus).erreur_execution !=
                                     d_ex_nom_implicite)                                      d_ex_nom_implicite) &&
                                       ((*s_etat_processus).erreur_execution !=
                                       d_ex_syntaxe))
                             {                              {
                                 (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                         d_ex_manque_argument;                                          d_ex_manque_argument;
Line 837  sequenceur(struct_processus *s_etat_proc Line 851  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 866  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 891  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 901  sequenceur(struct_processus *s_etat_proc Line 915  sequenceur(struct_processus *s_etat_proc
 */  */
   
                 if ((instruction_majuscule = conversion_majuscule(                  if ((instruction_majuscule = conversion_majuscule(
                         (*s_etat_processus).instruction_courante)) == NULL)                          s_etat_processus, (*s_etat_processus)
                           .instruction_courante)) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 922  sequenceur(struct_processus *s_etat_proc Line 937  sequenceur(struct_processus *s_etat_proc
                     (*((struct_fonction *) (*s_objet).objet))                      (*((struct_fonction *) (*s_objet).objet))
                             .nombre_arguments = 0;                              .nombre_arguments = 0;
   
                     if ((*s_etat_processus).instruction_intrinseque == 'Y')                      if (((*s_etat_processus).instruction_intrinseque == 'Y') &&
                               ((*s_etat_processus).instruction_sensible == 'N'))
                     {                      {
                         if (((*((struct_fonction *) (*s_objet).objet))                          if (((*((struct_fonction *) (*s_objet).objet))
                                 .nom_fonction = conversion_majuscule(                                  .nom_fonction = conversion_majuscule(
                                 (*s_etat_processus).instruction_courante))                                  s_etat_processus, (*s_etat_processus)
                                 == NULL)                                  .instruction_courante)) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
                                     d_es_allocation_memoire;                                      d_es_allocation_memoire;
Line 975  sequenceur(struct_processus *s_etat_proc Line 991  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 1001  sequenceur(struct_processus *s_etat_proc Line 1017  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Traitement des arrêts simples    Traitement des arrêts simples
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1017  sequenceur(struct_processus *s_etat_proc Line 1033  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 1039  sequenceur(struct_processus *s_etat_proc Line 1055  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 1089  sequenceur(struct_processus *s_etat_proc Line 1105  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);
         }          }
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   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 1190  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 1199  sequenceur(struct_processus *s_etat_proc Line 1215  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 1212  sequenceur(struct_processus *s_etat_proc Line 1228  sequenceur(struct_processus *s_etat_proc
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es;                          (*s_etat_processus).erreur_systeme = d_es;
                         instruction_majuscule = conversion_majuscule(                          instruction_majuscule = conversion_majuscule(
                                 (*s_etat_processus).instruction_courante);                                  s_etat_processus, (*s_etat_processus)
                                   .instruction_courante);
   
                         if (instruction_majuscule == NULL)                          if (instruction_majuscule == NULL)
                         {                          {
Line 1221  sequenceur(struct_processus *s_etat_proc Line 1238  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 1313  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 1347  sequenceur(struct_processus *s_etat_proc Line 1364  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 1400  sequenceur(struct_processus *s_etat_proc Line 1417  sequenceur(struct_processus *s_etat_proc
                     }                      }
                                           
                     instruction_majuscule = conversion_majuscule(                      instruction_majuscule = conversion_majuscule(
                               s_etat_processus,
                             (*s_etat_processus).instruction_courante);                              (*s_etat_processus).instruction_courante);
   
                     if (instruction_majuscule == NULL)                      if (instruction_majuscule == NULL)
Line 1462  sequenceur(struct_processus *s_etat_proc Line 1480  sequenceur(struct_processus *s_etat_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Messages d'erreur à afficher le cas échéant    Messages d'erreur à afficher le cas échéant
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1511  sequenceur(struct_processus *s_etat_proc Line 1529  sequenceur(struct_processus *s_etat_proc
         if ((*s_etat_processus).var_volatile_processus_pere == 0)          if ((*s_etat_processus).var_volatile_processus_pere == 0)
         {          {
             envoi_signal_processus((*s_etat_processus).pid_processus_pere,              envoi_signal_processus((*s_etat_processus).pid_processus_pere,
                     rpl_sigalrm);                      rpl_sigalrm, d_faux);
         }          }
         else          else
         {          {
Removed from v.1.59  
changed lines
  Added in v.1.105

CVSweb interface <joel.bertrand@systella.fr>