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

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

version 1.75, 2013/06/21 14:15:57 version 1.94, 2016/03/01 22:12:36
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.15    RPL/2 (R) version 4.1.25
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2016 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 197  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 216  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 265  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 295  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 333  sequenceur(struct_processus *s_etat_proc Line 335  sequenceur(struct_processus *s_etat_proc
                     }                      }
                     else                      else
                     {                      {
                           position_courante =
                                   (*s_etat_processus).position_courante;
                         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)
Line 456  sequenceur(struct_processus *s_etat_proc Line 460  sequenceur(struct_processus *s_etat_proc
                         {                             {   
                             liberation(s_etat_processus, s_objet);                              liberation(s_etat_processus, s_objet);
                         }                          }
   
                           (*s_etat_processus).position_courante =
                                   position_courante;
                     }                      }
                 }                  }
                 else if ((*s_etat_processus).invalidation_message_erreur                  else if ((*s_etat_processus).invalidation_message_erreur
Line 534  sequenceur(struct_processus *s_etat_proc Line 541  sequenceur(struct_processus *s_etat_proc
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               (*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 578  sequenceur(struct_processus *s_etat_proc Line 586  sequenceur(struct_processus *s_etat_proc
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
                         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] Évaluation de la variable "                                  if ((*s_etat_processus).langue == 'F')
                                   {
                                       printf("[%d] Évaluation de la variable "
                                         "partagée %s de type %d\n",                                          "partagée %s de type %d\n",
                                         (int) getpid(), (*s_etat_processus)                                          (int) getpid(), (*s_etat_processus)
                                         .instruction_courante,                                          .instruction_courante,
                                         (*(*(*s_etat_processus)                                          (*(*(*s_etat_processus)
                                         .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 (recherche_variable_partagee(s_etat_processus,                                  fflush(stdout);
                                 (*(*s_etat_processus)                              }
                                 .pointeur_variable_courante).nom,  
                                 (*(*s_etat_processus)  
                                 .pointeur_variable_courante).variable_partagee,  
                                 'P') != NULL)  
                         {  
                             // 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)
Line 646  sequenceur(struct_processus *s_etat_proc Line 654  sequenceur(struct_processus *s_etat_proc
                         else                          else
                         {                          {
                             // La variable n'existe plus.                              // La variable n'existe plus.
                               if ((*s_etat_processus).debug == d_vrai)
                                   if (((*s_etat_processus).type_debug &
                                           d_debug_variables) != 0)
                               {
                                   if ((*s_etat_processus).langue == 'F')
                                   {
                                       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);
                                   }
   
                                   fflush(stdout);
                               }
                         }                          }
                     }                      }
   
Line 792  sequenceur(struct_processus *s_etat_proc Line 822  sequenceur(struct_processus *s_etat_proc
 */  */
   
                     (*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 879  sequenceur(struct_processus *s_etat_proc Line 912  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 900  sequenceur(struct_processus *s_etat_proc Line 934  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 1190  sequenceur(struct_processus *s_etat_proc Line 1225  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 1378  sequenceur(struct_processus *s_etat_proc Line 1414  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)
Removed from v.1.75  
changed lines
  Added in v.1.94

CVSweb interface <joel.bertrand@systella.fr>