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

Diff for /rpl/src/evaluation.c between versions 1.10 and 1.11

version 1.10, 2010/04/07 13:45:02 version 1.11, 2010/04/17 18:57:35
Line 19 Line 19
 ================================================================================  ================================================================================
 */  */
   
   #define DEBUG_RETURN
 #include "rpl.conv.h"  #include "rpl.conv.h"
   
 #define TEST(instruction) (fonction == instruction)  #define TEST(instruction) (fonction == instruction)
Line 148  evaluation(struct_processus *s_etat_proc Line 148  evaluation(struct_processus *s_etat_proc
                     if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==                      if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
                             d_faux)                              d_faux)
                     {                      {
   uprintf("Paf !\n");
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_manque_argument;                                  d_ex_nom_implicite;
                         return(d_erreur);                          return(d_erreur);
                     }                      }
                 }                  }
Line 4013  evaluation(struct_processus *s_etat_proc Line 4014  evaluation(struct_processus *s_etat_proc
                                 {                                  {
                                     /*                                      /*
                                      * La fin de l'expression est atteinte,                                       * La fin de l'expression est atteinte,
                                      * le sequenceur reprend la main.                                       * le séquenceur reprend la main.
                                      */                                       */
   
                                     if (presence_egalite == d_vrai)                                      if (presence_egalite == d_vrai)
Line 4392  evaluation(struct_processus *s_etat_proc Line 4393  evaluation(struct_processus *s_etat_proc
                     if (recherche_variable(s_etat_processus, (*((struct_nom *)                      if (recherche_variable(s_etat_processus, (*((struct_nom *)
                             (*s_objet_elementaire).objet)).nom) == d_faux)                              (*s_objet_elementaire).objet)).nom) == d_faux)
                     {                      {
                           (*s_etat_processus).erreur_systeme = d_es;
                           presence_variable = d_faux;
   
                         if ((*s_etat_processus).autorisation_nom_implicite                          if ((*s_etat_processus).autorisation_nom_implicite
                                 == 'N')                                  == 'N')
                         {                          {
                             if ((*((struct_nom *) (*s_objet_elementaire).objet))                              if ((*((struct_nom *) (*s_objet_elementaire).objet))
                                     .symbole == d_faux)                                      .symbole == d_faux)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =  uprintf("Pif\n");
                                         d_es_nom_implicite;                                  (*s_etat_processus).erreur_execution =
                                 return(d_erreur);                                          d_ex_nom_implicite;
   
   /*
   ================================================================================
     Reprise sur erreur
     Réindentation du code
   ================================================================================
   */
   
   if ((*s_etat_processus).arret_si_exception == d_faux)
   {
   uprintf("(*s_etat_processus).arret_si_exception == d_faux\n");
       /*
        * Reprise sur erreur
        */
   
       if ((message = messages(s_etat_processus)) == NULL)
       {
           if (presence_egalite == d_vrai)
           {
               liberation(s_etat_processus,
                       s_objet_evalue);
           }
   
           (*s_etat_processus).instruction_courante =
                   instruction_courante;
           return(d_erreur);
       }
   
       free(message);
   
       while((*(*s_etat_processus).l_base_pile_systeme)
               .clause != 'R')
       {
           l_registre_atome = l_element_courant;
           l_element_courant = (*l_element_courant).suivant;
   
           if (l_element_courant == NULL)
           {
               /*
                * La fin de l'expression est atteinte,
                * le sequenceur reprend la main.
                */
   
               if (presence_egalite == d_vrai)
               {
                   liberation(s_etat_processus, s_objet_evalue);
               }
   
               (*s_etat_processus).mode_execution_programme =
                       registre_mode_execution_programme;
               return(d_absence_erreur);
           }
   
           if ((*(*l_element_courant).donnee).type == FCT)
           {
               (*s_etat_processus).instruction_courante = (*((struct_fonction *)
                       (*(*l_element_courant).donnee).objet)).nom_fonction;
   
               if (recherche_variable(s_etat_processus, (*s_etat_processus)
                       .instruction_courante) == d_faux)
               {
                   (*s_etat_processus).erreur_systeme = d_es;
                   fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)
                           .objet)).fonction;
   
                   /*
                    * Traitement de la pile système par les
                    * différentes instructions.
                    */
   
                   if (TEST(instruction_if) ||
                           TEST(instruction_iferr) ||
                           TEST(instruction_do) ||
                           TEST(instruction_while) ||
                           TEST(instruction_for) ||
                           TEST(instruction_start) ||
                           TEST(instruction_select) ||
                           TEST(instruction_case) ||
                           TEST(vers_niveau_superieur))
                   {
                       if (TEST(vers_niveau_superieur))
                       {
                           registre_exception = (*s_etat_processus).exception;
                           registre_erreur_execution = (*s_etat_processus)
                                   .erreur_execution;
   
                           analyse(s_etat_processus, vers_niveau_superieur);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
   
                           (*s_etat_processus).exception = registre_exception;
                           (*s_etat_processus).erreur_execution =
                                   registre_erreur_execution;
                       }
                       else
                       {
                           empilement_pile_systeme(s_etat_processus);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               if (presence_egalite == d_vrai)
                               {
                                   liberation(s_etat_processus,
                                           s_objet_evalue);
                             }                              }
   
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                         }                          }
                       }
                   }
                   else if (TEST(instruction_end) ||
                           TEST(instruction_next) ||
                           TEST(instruction_step) ||
                           TEST(vers_niveau_inferieur))
                   {
                       if (TEST(vers_niveau_inferieur))
                       {
                           registre_exception = (*s_etat_processus).exception;
                           registre_erreur_execution = (*s_etat_processus)
                                   .erreur_execution;
   
                         (*s_etat_processus).erreur_systeme = d_es;                          analyse(s_etat_processus, vers_niveau_inferieur);
                         presence_variable = d_faux;  
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
   
                           (*s_etat_processus).exception = registre_exception;
                           (*s_etat_processus).erreur_execution =
                                   registre_erreur_execution;
                       }
                       else
                       {
                           depilement_pile_systeme(s_etat_processus);
   
                           if ((*s_etat_processus)
                                   .erreur_systeme != d_es)
                           {
                               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).instruction_courante = instruction_courante;
       drapeau_then = d_faux;
   
       do
       {
           l_registre_atome = l_element_courant;
   
           if (l_element_courant == NULL)
           {
               /*
                * La fin de l'expression est atteinte,
                * le sequenceur reprend la main.
                */
   
               if (presence_egalite == d_vrai)
               {
                   liberation(s_etat_processus, s_objet_evalue);
               }
   
               (*s_etat_processus).mode_execution_programme =
                       registre_mode_execution_programme;
               (*s_etat_processus).instruction_courante = instruction_courante;
               return(d_absence_erreur);
           }
   
           if ((*(*l_element_courant).donnee).type == FCT)
           {
               (*s_etat_processus).instruction_courante = (*((struct_fonction *)
                       (*(*l_element_courant).donnee).objet)).nom_fonction;
               fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)
                       .objet)).fonction;
               (*s_etat_processus).instruction_courante = instruction_courante;
   
               drapeau_then = TEST(instruction_then) ? d_vrai : d_faux;
           }
   
           l_element_courant = (*l_element_courant) .suivant;
       } while(drapeau_then == d_faux);
   
       (*s_etat_processus).expression_courante = l_registre_atome;
   
       (*(*s_etat_processus).l_base_pile_systeme).clause = 'X';
       instruction_then(s_etat_processus);
   
       (*s_etat_processus).exception = d_ep;
       (*s_etat_processus).erreur_execution = d_ex;
   }
   else if ((*s_etat_processus).mode_evaluation_expression == 'Y')
   {
   uprintf("(*s_etat_processus).mode_evaluation_expression == 'Y'\n");
       /*
        * Reprise sur erreur
        */
   
       while(l_element_courant != NULL)
       {
           if ((*(*l_element_courant).donnee).type == FCT)
           {
               (*s_etat_processus).instruction_courante = (*((struct_fonction *)
                       (*(*l_element_courant).donnee).objet)).nom_fonction;
               fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)
                       .objet)).fonction;
   
               if (recherche_variable(s_etat_processus, (*s_etat_processus)
                       .instruction_courante) == d_faux)
               {
                   (*s_etat_processus).erreur_systeme = d_es;
   
                   /*
                    * Traitement de la pile système par les
                    * différentes instructions.
                    */
   
                   if (TEST(instruction_if) ||
                           TEST(instruction_iferr) ||
                           TEST(instruction_do) ||
                           TEST(instruction_while) ||
                           TEST(instruction_for) ||
                           TEST(instruction_start) ||
                           TEST(instruction_select) ||
                           TEST(instruction_case) ||
                           TEST(vers_niveau_superieur))
                   {
                       if (TEST(vers_niveau_superieur))
                       {
                           analyse(s_etat_processus, vers_niveau_superieur);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                       else
                       {
                           empilement_pile_systeme(s_etat_processus);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               if (presence_egalite == d_vrai)
                               {
                                   liberation(s_etat_processus, s_objet_evalue);
                               }
   
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                   }
                   else if (TEST(instruction_end) ||
                           TEST(instruction_next) ||
                           TEST(instruction_step) ||
                           TEST(vers_niveau_inferieur))
                   {
                       if (TEST(vers_niveau_inferieur))
                       {
                           analyse(s_etat_processus, vers_niveau_inferieur);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                       else
                       {
                           depilement_pile_systeme(s_etat_processus);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               if (presence_egalite == d_vrai)
                               {
                                   liberation(s_etat_processus,
                                           s_objet_evalue);
                               }
   
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                   }
               }
           }
   
           l_element_courant = (*l_element_courant).suivant;
       }
   
       (*s_etat_processus).mode_execution_programme =
               registre_mode_execution_programme;
       (*s_etat_processus).instruction_courante = instruction_courante;
   
       (*s_etat_processus).exception = d_ep;
       (*s_etat_processus).erreur_execution = d_ex;
   
       erreur_evaluation = d_erreur;
   }
   else
   {
   uprintf("Default\n");
       // On ne détruit pas les variables pour les inclure
       // dans le fichier rpl-core.
   
       (*s_etat_processus).gel_liste_variables = d_vrai;
   
       registre_erreur_execution = (*s_etat_processus).erreur_execution;
       registre_exception = (*s_etat_processus).exception;
       registre_erreur_systeme = (*s_etat_processus).erreur_systeme;
   
       (*s_etat_processus).s_objet_errone = s_objet;
       (*s_etat_processus).s_objet_erreur = (*l_element_courant).donnee;
   
       l_element_courant = (*l_element_courant).suivant;
   
       while(l_element_courant != NULL)
       {
           if ((*(*l_element_courant).donnee).type == FCT)
           {
               (*s_etat_processus).instruction_courante = (*((struct_fonction *)
                       (*(*l_element_courant).donnee).objet)).nom_fonction;
               fonction = (*((struct_fonction *) (*(*l_element_courant).donnee)
                       .objet)).fonction;
   
               if (recherche_variable(s_etat_processus, (*s_etat_processus)
                       .instruction_courante) == d_faux)
               {
                   (*s_etat_processus).erreur_systeme = d_es;
   
                   /*
                    * Traitement de la pile système par les
                    * différentes instructions.
                    */
   
                   if (TEST(instruction_if) ||
                           TEST(instruction_iferr) ||
                           TEST(instruction_do) ||
                           TEST(instruction_while) ||
                           TEST(instruction_for) ||
                           TEST(instruction_start) ||
                           TEST(instruction_select) ||
                           TEST(instruction_case) ||
                           TEST(vers_niveau_superieur))
                   {
                       if (TEST(vers_niveau_superieur))
                       {
                           analyse(s_etat_processus, vers_niveau_superieur);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                       else
                       {
                           empilement_pile_systeme(s_etat_processus);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               if (presence_egalite == d_vrai)
                               {
                                   liberation(s_etat_processus,
                                           s_objet_evalue);
                               }
   
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                   }
                   else if (TEST(instruction_end) ||
                           TEST(instruction_next) ||
                           TEST(instruction_step) ||
                           TEST(vers_niveau_inferieur))
                   {
                       if (TEST(vers_niveau_inferieur))
                       {
                           analyse(s_etat_processus, vers_niveau_inferieur);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                       else
                       {
                           depilement_pile_systeme(s_etat_processus);
   
                           if ((*s_etat_processus).erreur_systeme != d_es)
                           {
                               if (presence_egalite == d_vrai)
                               {
                                   liberation(s_etat_processus, s_objet_evalue);
                               }
   
                               (*s_etat_processus).instruction_courante =
                                       instruction_courante;
                               return(d_erreur);
                           }
                       }
                   }
               }
           }
   
           l_element_courant = (*l_element_courant).suivant;
       }
   
       (*s_etat_processus).mode_execution_programme =
               registre_mode_execution_programme;
       (*s_etat_processus).instruction_courante = instruction_courante;
   
       if (presence_egalite == d_vrai)
       {
           liberation(s_etat_processus, s_objet_evalue);
       }
   
       if ((*s_etat_processus).var_volatile_processus_pere == 0)
       {
           kill((*s_etat_processus).pid_processus_pere, SIGALRM);
       }
       else
       {
           (*s_etat_processus).var_volatile_alarme = -1;
       }
   
       (*s_etat_processus).erreur_execution = registre_erreur_execution;
       (*s_etat_processus).erreur_systeme = registre_erreur_systeme;
       (*s_etat_processus).exception = registre_exception;
   printf("%d\n", (*s_etat_processus).erreur_execution);
   printf("<%d>\n", (*s_etat_processus).invalidation_message_erreur);
       return(d_erreur);
   }
   
   /*
   ================================================================================
     Fin de la réindentation
   ================================================================================
   */
   
                               }
                           }
                     }                      }
                     else                      else
                     {                      {
Line 5099  evaluation(struct_processus *s_etat_proc Line 5569  evaluation(struct_processus *s_etat_proc
                             ((*s_etat_processus).erreur_execution != d_ex) ||                              ((*s_etat_processus).erreur_execution != d_ex) ||
                             ((*s_etat_processus).exception != d_ep))                              ((*s_etat_processus).exception != d_ep))
                     {                      {
                           // Il est anormal de récupérer ici une erreur
                           // d'exécution puisqu'on empile une constante
                           // symbolique.
   
                         if (presence_egalite == d_vrai)                          if (presence_egalite == d_vrai)
                         {                          {
                             liberation(s_etat_processus, s_objet_evalue);                              liberation(s_etat_processus, s_objet_evalue);
Removed from v.1.10  
changed lines
  Added in v.1.11

CVSweb interface <joel.bertrand@systella.fr>