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

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

version 1.11, 2010/04/17 18:57:35 version 1.12, 2010/04/20 12:49:18
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 143  evaluation(struct_processus *s_etat_proc Line 143  evaluation(struct_processus *s_etat_proc
             if (recherche_variable(s_etat_processus, (*((struct_nom *)              if (recherche_variable(s_etat_processus, (*((struct_nom *)
                     (*s_objet_tampon).objet)).nom) == d_faux)                      (*s_objet_tampon).objet)).nom) == d_faux)
             {              {
                   (*s_etat_processus).erreur_execution = d_ex;
   
                 if ((*s_etat_processus).autorisation_nom_implicite == 'N')                  if ((*s_etat_processus).autorisation_nom_implicite == 'N')
                 {                  {
                     if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==                      if ((*((struct_nom *) (*s_objet_tampon).objet)).symbole ==
                             d_faux)                              d_faux)
                     {                      {
 uprintf("Paf !\n");                          if (test_cfsf(s_etat_processus, 31) == d_vrai)
                           {
                               if (empilement_pile_last(s_etat_processus, 0)
                                       == d_erreur)
                               {
                                   return(d_erreur);
                               }
                           }
   
                           erreur_evaluation = d_erreur;
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_nom_implicite;                                  d_ex_nom_implicite;
                         return(d_erreur);  
                           if (type_evaluation == 'I')
                           {
                               (*s_etat_processus).derniere_erreur_evaluation =
                                       (*s_etat_processus).erreur_execution;
                           }
                     }                      }
                 }                  }
   
Line 475  uprintf("Paf !\n"); Line 491  uprintf("Paf !\n");
                 (*s_etat_processus).evaluation_expression_compilee =                  (*s_etat_processus).evaluation_expression_compilee =
                         registre_evaluation_expression_compilee;                          registre_evaluation_expression_compilee;
             }              }
             else              else if ((*s_etat_processus).erreur_execution != d_ex_nom_implicite)
             {              {
                 if ((s_objet_tampon = copie_objet(s_etat_processus,                  if ((s_objet_tampon = copie_objet(s_etat_processus,
                         s_objet, 'P')) == NULL)                          s_objet, 'Q')) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 496  uprintf("Paf !\n"); Line 512  uprintf("Paf !\n");
                             instruction_courante;                              instruction_courante;
                     return(d_erreur);                      return(d_erreur);
                 }                  }
   
                 if ((*s_etat_processus).erreur_execution ==  
                         d_ex_variable_non_definie)  
                 {  
                     (*s_etat_processus).erreur_execution = d_ex;  
                 }  
             }              }
         }          }
         else          else
Line 4402  uprintf("Paf !\n"); Line 4412  uprintf("Paf !\n");
                             if ((*((struct_nom *) (*s_objet_elementaire).objet))                              if ((*((struct_nom *) (*s_objet_elementaire).objet))
                                     .symbole == d_faux)                                      .symbole == d_faux)
                             {                              {
 uprintf("Pif\n");                                  if (test_cfsf(s_etat_processus, 31) == d_vrai)
                                   {
                                       if (empilement_pile_last(s_etat_processus,
                                               0) == d_erreur)
                                       {
                                           return(d_erreur);
                                       }
                                   }
   
                                   erreur_evaluation = d_erreur;
                                 (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                         d_ex_nom_implicite;                                          d_ex_nom_implicite;
   
 /*                                  if (type_evaluation == 'I')
 ================================================================================                                  {
   Reprise sur erreur                                      (*s_etat_processus)
   Réindentation du code                                              .derniere_erreur_evaluation =
 ================================================================================                                              (*s_etat_processus)
 */                                              .erreur_execution;
                                   }
 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;  
   
                         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);  
                         }  
   
                         (*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  
 ================================================================================  
 */  
   
                             }                              }
                         }                          }
                     }                      }
Removed from v.1.11  
changed lines
  Added in v.1.12

CVSweb interface <joel.bertrand@systella.fr>