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

Diff for /rpl/src/evaluation.c between versions 1.42 and 1.56

version 1.42, 2011/06/24 20:31:35 version 1.56, 2012/09/15 12:57:09
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.4    RPL/2 (R) version 4.1.10
   Copyright (C) 1989-2011 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 822  evaluation(struct_processus *s_etat_proc Line 822  evaluation(struct_processus *s_etat_proc
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm);
                         }                          }
                         else                          else
                         {                          {
Line 915  evaluation(struct_processus *s_etat_proc Line 915  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 932  evaluation(struct_processus *s_etat_proc Line 933  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 987  evaluation(struct_processus *s_etat_proc Line 996  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 1001  evaluation(struct_processus *s_etat_proc Line 1018  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           liberation(
                                                           s_etat_processus,
                                                           s_objet_evalue);
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 1087  evaluation(struct_processus *s_etat_proc Line 1153  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 1097  evaluation(struct_processus *s_etat_proc Line 1164  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 1139  evaluation(struct_processus *s_etat_proc Line 1214  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 1147  evaluation(struct_processus *s_etat_proc Line 1230  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
                                             }                                              }
Line 1240  evaluation(struct_processus *s_etat_proc Line 1379  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 1250  evaluation(struct_processus *s_etat_proc Line 1390  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 1292  evaluation(struct_processus *s_etat_proc Line 1440  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 1308  evaluation(struct_processus *s_etat_proc Line 1464  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                               .erreur_systeme =
                                                               d_es_processus;
                                                           return(d_erreur);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .sections_critiques--;
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 1349  evaluation(struct_processus *s_etat_proc Line 1560  evaluation(struct_processus *s_etat_proc
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm);
                             }                              }
                             else                              else
                             {                              {
Line 3146  evaluation(struct_processus *s_etat_proc Line 3357  evaluation(struct_processus *s_etat_proc
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm);
                         }                          }
                         else                          else
                         {                          {
Line 3238  evaluation(struct_processus *s_etat_proc Line 3449  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3255  evaluation(struct_processus *s_etat_proc Line 3467  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3310  evaluation(struct_processus *s_etat_proc Line 3530  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3324  evaluation(struct_processus *s_etat_proc Line 3552  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3448  evaluation(struct_processus *s_etat_proc Line 3728  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3458  evaluation(struct_processus *s_etat_proc Line 3739  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3500  evaluation(struct_processus *s_etat_proc Line 3789  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3508  evaluation(struct_processus *s_etat_proc Line 3805  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3598  evaluation(struct_processus *s_etat_proc Line 3947  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3608  evaluation(struct_processus *s_etat_proc Line 3958  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3650  evaluation(struct_processus *s_etat_proc Line 4008  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3658  evaluation(struct_processus *s_etat_proc Line 4024  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 3699  evaluation(struct_processus *s_etat_proc Line 4117  evaluation(struct_processus *s_etat_proc
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm);
                             }                              }
                             else                              else
                             {                              {
Line 3727  evaluation(struct_processus *s_etat_proc Line 4145  evaluation(struct_processus *s_etat_proc
                         if ((*s_etat_processus).var_volatile_processus_pere                          if ((*s_etat_processus).var_volatile_processus_pere
                                 == 0)                                  == 0)
                         {                          {
                             kill((*s_etat_processus)                              envoi_signal_processus((*s_etat_processus)
                                     .pid_processus_pere, SIGALRM);                                      .pid_processus_pere, rpl_sigalrm);
                         }                          }
                         else                          else
                         {                          {
Line 3819  evaluation(struct_processus *s_etat_proc Line 4237  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 3836  evaluation(struct_processus *s_etat_proc Line 4255  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3891  evaluation(struct_processus *s_etat_proc Line 4318  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 3905  evaluation(struct_processus *s_etat_proc Line 4340  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4029  evaluation(struct_processus *s_etat_proc Line 4516  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 4039  evaluation(struct_processus *s_etat_proc Line 4527  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 4081  evaluation(struct_processus *s_etat_proc Line 4577  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 4089  evaluation(struct_processus *s_etat_proc Line 4593  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4179  evaluation(struct_processus *s_etat_proc Line 4735  evaluation(struct_processus *s_etat_proc
                                                 TEST(instruction_start) ||                                                  TEST(instruction_start) ||
                                                 TEST(instruction_select) ||                                                  TEST(instruction_select) ||
                                                 TEST(instruction_case) ||                                                  TEST(instruction_case) ||
                                                   TEST(instruction_critical) ||
                                                 TEST(vers_niveau_superieur))                                                  TEST(vers_niveau_superieur))
                                         {                                          {
                                             if (TEST(vers_niveau_superieur))                                              if (TEST(vers_niveau_superieur))
Line 4189  evaluation(struct_processus *s_etat_proc Line 4746  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 4231  evaluation(struct_processus *s_etat_proc Line 4796  evaluation(struct_processus *s_etat_proc
                                                 if ((*s_etat_processus)                                                  if ((*s_etat_processus)
                                                         .erreur_systeme != d_es)                                                          .erreur_systeme != d_es)
                                                 {                                                  {
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                     (*s_etat_processus)                                                      (*s_etat_processus)
                                                         .instruction_courante =                                                          .instruction_courante =
                                                         instruction_courante;                                                          instruction_courante;
Line 4239  evaluation(struct_processus *s_etat_proc Line 4812  evaluation(struct_processus *s_etat_proc
                                             }                                              }
                                             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_end_incoherent;
   
                                                       if (presence_egalite ==
                                                               d_vrai)
                                                       {
                                                           liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                       }
   
                                                       (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                       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;
   
                                                           if (presence_egalite ==
                                                                   d_vrai)
                                                           {
                                                               liberation(
                                                               s_etat_processus,
                                                               s_objet_evalue);
                                                           }
   
                                                           (*s_etat_processus)
                                                           .instruction_courante =
                                                           instruction_courante;
                                                           return(d_erreur);
                                                       }
                                                   }
   
                                                 depilement_pile_systeme(                                                  depilement_pile_systeme(
                                                         s_etat_processus);                                                          s_etat_processus);
   
Line 4280  evaluation(struct_processus *s_etat_proc Line 4905  evaluation(struct_processus *s_etat_proc
                             if ((*s_etat_processus)                              if ((*s_etat_processus)
                                     .var_volatile_processus_pere == 0)                                      .var_volatile_processus_pere == 0)
                             {                              {
                                 kill((*s_etat_processus)                                  envoi_signal_processus((*s_etat_processus)
                                         .pid_processus_pere, SIGALRM);                                          .pid_processus_pere, rpl_sigalrm);
                             }                              }
                             else                              else
                             {                              {
Removed from v.1.42  
changed lines
  Added in v.1.56

CVSweb interface <joel.bertrand@systella.fr>