Diff for /rpl/src/instructions_c2.c between versions 1.31 and 1.71

version 1.31, 2012/01/05 10:19:00 version 1.71, 2018/05/30 09:27:33
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.5    RPL/2 (R) version 4.1.29
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2018 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 47  instruction_cycle(struct_processus *s_et Line 47  instruction_cycle(struct_processus *s_et
     unsigned char                   *instruction_majuscule;      unsigned char                   *instruction_majuscule;
     unsigned char                   *tampon;      unsigned char                   *tampon;
   
     unsigned long                   niveau;      integer8                        niveau;
   
     void                            (*fonction)();      void                            (*fonction)();
   
Line 74  instruction_cycle(struct_processus *s_et Line 74  instruction_cycle(struct_processus *s_et
         printf("        ...\n");          printf("        ...\n");
         printf("    NEXT/STEP\n\n");          printf("    NEXT/STEP\n\n");
   
           printf("    FORALL (variable)\n");
           printf("        ...\n");
           printf("        CYCLE\n");
           printf("        ...\n");
           printf("    NEXT\n\n");
   
         printf("    START\n");          printf("    START\n");
         printf("        ...\n");          printf("        ...\n");
         printf("        CYCLE\n");          printf("        CYCLE\n");
Line 98  instruction_cycle(struct_processus *s_et Line 104  instruction_cycle(struct_processus *s_et
     while((l_element_pile_systeme != NULL) && (presence_boucle == d_faux))      while((l_element_pile_systeme != NULL) && (presence_boucle == d_faux))
     {      {
         if (((*l_element_pile_systeme).type_cloture == 'S') ||          if (((*l_element_pile_systeme).type_cloture == 'S') ||
                 ((*l_element_pile_systeme).type_cloture == 'F'))                  ((*l_element_pile_systeme).type_cloture == 'F') ||
                   ((*l_element_pile_systeme).type_cloture == 'A'))
         {          {
             presence_boucle = d_vrai;              presence_boucle = d_vrai;
         }          }
Line 118  instruction_cycle(struct_processus *s_et Line 125  instruction_cycle(struct_processus *s_et
         tampon = (*s_etat_processus).instruction_courante;          tampon = (*s_etat_processus).instruction_courante;
         niveau = 1;          niveau = 1;
   
         instruction_majuscule = conversion_majuscule("");          instruction_majuscule = conversion_majuscule(s_etat_processus, "");
   
         while(!(((strcmp(instruction_majuscule, "NEXT") == 0) ||          while(!(((strcmp(instruction_majuscule, "NEXT") == 0) ||
                 (strcmp(instruction_majuscule, "STEP") == 0)) && (niveau == 0)))                  (strcmp(instruction_majuscule, "STEP") == 0)) && (niveau == 0)))
Line 132  instruction_cycle(struct_processus *s_et Line 139  instruction_cycle(struct_processus *s_et
                 return;                  return;
             }              }
   
             if (recherche_variable(s_etat_processus,              instruction_majuscule = conversion_majuscule(s_etat_processus,
                     (*s_etat_processus).instruction_courante) == d_vrai)                      (*s_etat_processus).instruction_courante);
   
               if (instruction_majuscule == NULL)
             {              {
                 instruction_majuscule = conversion_majuscule("");                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
                 if ((*(*s_etat_processus).pointeur_variable_courante).objet              /*
                         == NULL)               * Traitement de la pile système par les
                * différentes instructions.
                */
   
               if ((strcmp(instruction_majuscule, "IF") == 0) ||
                       (strcmp(instruction_majuscule, "IFERR") == 0) ||
                       (strcmp(instruction_majuscule, "DO") == 0) ||
                       (strcmp(instruction_majuscule, "WHILE") == 0) ||
                       (strcmp(instruction_majuscule, "FOR") == 0) ||
                       (strcmp(instruction_majuscule, "FORALL") == 0) ||
                       (strcmp(instruction_majuscule, "START") == 0) ||
                       (strcmp(instruction_majuscule, "SELECT") == 0)
                       || (strcmp(instruction_majuscule, "CRITICAL") == 0)
                       || (strcmp(instruction_majuscule, "CASE") == 0)
                       || (strcmp(instruction_majuscule, "<<") == 0))
               {
                   if (strcmp(instruction_majuscule, "<<") == 0)
                 {                  {
                     // Variable partagée                      analyse(s_etat_processus, NULL);
   
                     if (pthread_mutex_lock(&((*(*s_etat_processus)  
                             .s_liste_variables_partagees).mutex)) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
   
                     if (recherche_variable_partagee(s_etat_processus,  
                             (*(*s_etat_processus).pointeur_variable_courante)  
                             .nom, (*(*s_etat_processus)  
                             .pointeur_variable_courante).variable_partagee,  
                             'E') == d_vrai)  
                     {  
                         if ((*((*(*s_etat_processus)  
                                 .s_liste_variables_partagees).table  
                                 [(*(*s_etat_processus)  
                                 .s_liste_variables_partagees)  
                                 .position_variable])  
                                 .objet).type == ADR)  
                         {  
                             empilement_pile_systeme(s_etat_processus);  
   
                             if ((*s_etat_processus).erreur_systeme != d_es)  
                             {  
                                 if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                                         .s_liste_variables_partagees).mutex))  
                                         != 0)  
                                 {  
                                     (*s_etat_processus).erreur_systeme =  
                                             d_es_processus;  
                                     return;  
                                 }  
   
                                 return;  
                             }  
   
                             (*(*s_etat_processus).l_base_pile_systeme)  
                                     .adresse_retour =  
                                     (*s_etat_processus).position_courante;  
   
                             (*(*s_etat_processus).l_base_pile_systeme)  
                                     .retour_definition = 'Y';  
                             (*(*s_etat_processus).l_base_pile_systeme)  
                                     .niveau_courant =  
                                     (*s_etat_processus).niveau_courant;  
   
                             (*s_etat_processus).position_courante =  
                                     (*((unsigned long *)  
                                     ((*(*(*s_etat_processus)  
                                     .pointeur_variable_courante).objet)  
                                     .objet)));  
   
                             (*s_etat_processus)  
                                     .autorisation_empilement_programme = 'N';  
                         }  
                     }  
   
                     if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                             .s_liste_variables_partagees).mutex)) != 0)  
                     {  
                         (*s_etat_processus).erreur_systeme = d_es_processus;  
                         return;  
                     }  
                 }                  }
                 else                  else
                 {                  {
                     // Variable privée                      if ((strcmp(instruction_majuscule, "FOR") == 0) ||
                               (strcmp(instruction_majuscule, "FORALL") == 0) ||
                     if ((*(*(*s_etat_processus).pointeur_variable_courante)                              (strcmp(instruction_majuscule, "START") == 0))
                             .objet).type == ADR)  
                     {                      {
                         empilement_pile_systeme(s_etat_processus);                          niveau++;
                       }
                         if ((*s_etat_processus).erreur_systeme != d_es)  
                         {  
                             return;  
                         }  
   
                         (*(*s_etat_processus).l_base_pile_systeme)                      empilement_pile_systeme(s_etat_processus);
                                 .adresse_retour =  
                                 (*s_etat_processus).position_courante;  
   
                         (*(*s_etat_processus).l_base_pile_systeme)  
                                 .retour_definition = 'Y';  
                         (*(*s_etat_processus).l_base_pile_systeme)  
                                 .niveau_courant =  
                                 (*s_etat_processus).niveau_courant;  
   
                         (*s_etat_processus).position_courante =  
                                 (*((unsigned long *) ((*(*(*s_etat_processus)  
                                 .pointeur_variable_courante).objet).objet)));  
   
                         (*s_etat_processus).autorisation_empilement_programme                      if ((*s_etat_processus).erreur_systeme != d_es)
                                 = 'N';                      {
                           return;
                     }                      }
                 }                  }
             }              }
             else              else if ((strcmp(instruction_majuscule, "END") == 0) ||
                       (strcmp(instruction_majuscule, "NEXT") == 0) ||
                       (strcmp(instruction_majuscule, "STEP") == 0) ||
                       (strcmp(instruction_majuscule, ">>") == 0))
             {              {
                 (*s_etat_processus).erreur_systeme = d_es;                  if (strcmp(instruction_majuscule, ">>") == 0)
                 instruction_majuscule = conversion_majuscule(  
                         (*s_etat_processus).instruction_courante);  
   
                 if (instruction_majuscule == NULL)  
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      analyse(s_etat_processus, NULL);
                             d_es_allocation_memoire;  
                     return;  
                 }  
   
                 /*                      if ((*s_etat_processus).retour_routine_evaluation
                  * Traitement de la pile système par les                              == 'Y')
                  * différentes instructions.  
                  */  
   
                 if ((strcmp(instruction_majuscule, "IF") == 0) ||  
                         (strcmp(instruction_majuscule, "IFERR") == 0) ||  
                         (strcmp(instruction_majuscule, "DO") == 0) ||  
                         (strcmp(instruction_majuscule, "WHILE") == 0) ||  
                         (strcmp(instruction_majuscule, "FOR") == 0) ||  
                         (strcmp(instruction_majuscule, "START") == 0) ||  
                         (strcmp(instruction_majuscule, "SELECT") == 0)  
                         || (strcmp(instruction_majuscule, "CASE") == 0)  
                         || (strcmp(instruction_majuscule, "<<") == 0))  
                 {  
                     if (strcmp(instruction_majuscule, "<<") == 0)  
                     {                      {
                         analyse(s_etat_processus, NULL);                          drapeau_presence_fin_boucle = d_faux;
                     }                          free((*s_etat_processus).instruction_courante);
                     else  
                     {  
                         if ((strcmp(instruction_majuscule, "FOR") == 0) ||  
                                 (strcmp(instruction_majuscule, "START") == 0))  
                         {  
                             niveau++;  
                         }  
   
                         empilement_pile_systeme(s_etat_processus);  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                          break;
                         {  
                             return;  
                         }  
                     }                      }
                 }                  }
                 else if ((strcmp(instruction_majuscule, "END") == 0) ||                  else
                         (strcmp(instruction_majuscule, "NEXT") == 0) ||  
                         (strcmp(instruction_majuscule, "STEP") == 0) ||  
                         (strcmp(instruction_majuscule, ">>") == 0))  
                 {                  {
                     if (strcmp(instruction_majuscule, ">>") == 0)                      if ((strcmp(instruction_majuscule, "NEXT") == 0) ||
                               (strcmp(instruction_majuscule, "STEP") == 0))
                     {                      {
                         analyse(s_etat_processus, NULL);                          niveau--;
   
                         if ((*s_etat_processus).retour_routine_evaluation                          if (niveau != 0)
                                 == 'Y')  
                         {                          {
                             drapeau_presence_fin_boucle = d_faux;                              depilement_pile_systeme(s_etat_processus);
                             free((*s_etat_processus).instruction_courante);  
   
                             break;  
                         }                          }
                     }                      }
                     else                      else
                     {                      {
                         if ((strcmp(instruction_majuscule, "NEXT") == 0) ||                          if ((*s_etat_processus).l_base_pile_systeme == NULL)
                                 (strcmp(instruction_majuscule, "STEP") == 0))  
                         {                          {
                             niveau--;                              (*s_etat_processus).erreur_systeme =
                                       d_es_processus;
                               return;
                           }
   
                             if (niveau != 0)                          if ((*(*s_etat_processus).l_base_pile_systeme)
                                   .type_cloture == 'Q')
                           {
                               if (pthread_mutex_unlock(
                                       &mutex_sections_critiques) != 0)
                             {                              {
                                 depilement_pile_systeme(s_etat_processus);                                  (*s_etat_processus).erreur_systeme =
                                           d_es_processus;
                                   return;
                             }                              }
                         }  
                         else  
                         {  
                             depilement_pile_systeme(s_etat_processus);  
                         }  
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                              (*s_etat_processus).sections_critiques--;
                         {  
                             return;  
                         }                          }
   
                           depilement_pile_systeme(s_etat_processus);
                       }
   
                       if ((*s_etat_processus).erreur_systeme != d_es)
                       {
                           return;
                     }                      }
                 }                  }
             }              }
Line 381  instruction_cycle(struct_processus *s_et Line 300  instruction_cycle(struct_processus *s_et
                     (fonction == instruction_do) ||                      (fonction == instruction_do) ||
                     (fonction == instruction_while) ||                      (fonction == instruction_while) ||
                     (fonction == instruction_for) ||                      (fonction == instruction_for) ||
                       (fonction == instruction_forall) ||
                     (fonction == instruction_start) ||                      (fonction == instruction_start) ||
                     (fonction == instruction_select) ||                      (fonction == instruction_select) ||
                     (fonction == instruction_case) ||                      (fonction == instruction_case) ||
                       (fonction == instruction_critical) ||
                     (fonction == instruction_vers_niveau_superieur))                      (fonction == instruction_vers_niveau_superieur))
             {              {
                 if (fonction == instruction_vers_niveau_superieur)                  if (fonction == instruction_vers_niveau_superieur)
Line 394  instruction_cycle(struct_processus *s_et Line 315  instruction_cycle(struct_processus *s_et
                 else                  else
                 {                  {
                     if ((fonction == instruction_for) ||                      if ((fonction == instruction_for) ||
                               (fonction == instruction_forall) ||
                             (fonction == instruction_start))                              (fonction == instruction_start))
                     {                      {
                         niveau++;                          niveau++;
Line 436  instruction_cycle(struct_processus *s_et Line 358  instruction_cycle(struct_processus *s_et
                     }                      }
                     else                      else
                     {                      {
                           if ((*s_etat_processus).l_base_pile_systeme == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_processus;
                               return;
                           }
   
                           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;
                                   return;
                               }
   
                               (*s_etat_processus).sections_critiques--;
                           }   
   
                         depilement_pile_systeme(s_etat_processus);                          depilement_pile_systeme(s_etat_processus);
                     }                      }
   
Line 495  instruction_con(struct_processus *s_etat Line 438  instruction_con(struct_processus *s_etat
     struct_objet                    *s_objet_resultat;      struct_objet                    *s_objet_resultat;
   
     logical1                        argument_nom;      logical1                        argument_nom;
       logical1                        variable_partagee;
   
     unsigned long                   i;      integer8                        i;
     unsigned long                   j;      integer8                        j;
     unsigned long                   nombre_colonnes;      integer8                        nombre_colonnes;
     unsigned long                   nombre_dimensions;      integer8                        nombre_dimensions;
     unsigned long                   nombre_lignes;      integer8                        nombre_lignes;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 612  instruction_con(struct_processus *s_etat Line 556  instruction_con(struct_processus *s_etat
         {          {
             // Variable partagée              // Variable partagée
   
             if (pthread_mutex_lock(&((*(*s_etat_processus)              variable_partagee = d_vrai;
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             if (recherche_variable_partagee(s_etat_processus,              if (recherche_variable_partagee(s_etat_processus,
                     (*(*s_etat_processus).pointeur_variable_courante).nom,                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     (*(*s_etat_processus).pointeur_variable_courante)                      (*(*s_etat_processus).pointeur_variable_courante)
                     .variable_partagee, (*(*s_etat_processus)                      .variable_partagee, (*(*s_etat_processus)
                     .pointeur_variable_courante).origine)                      .pointeur_variable_courante).origine)
                     == d_faux)                      == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es;                  (*s_etat_processus).erreur_systeme = d_es;
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_variable_non_definie;                          d_ex_variable_non_definie;
   
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables_partagees).mutex)) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 liberation(s_etat_processus, s_objet_1);                  liberation(s_etat_processus, s_objet_1);
                 liberation(s_etat_processus, s_objet_2);                  liberation(s_etat_processus, s_objet_2);
   
                 return;                  return;
             }              }
   
             s_objet_2 = (*(*s_etat_processus).s_liste_variables_partagees)              s_objet_2 = (*(*s_etat_processus)
                     .table[(*(*s_etat_processus).s_liste_variables_partagees)                      .pointeur_variable_partagee_courante).objet;
                     .position_variable].objet;  
   
             if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
         }          }
         else          else
         {          {
             // Variable privée              // Variable privée
   
             s_objet_2 = (*(*s_etat_processus).pointeur_variable_courante).objet;              s_objet_2 = (*(*s_etat_processus).pointeur_variable_courante).objet;
               variable_partagee = d_faux;
         }          }
     }      }
     else      else
     {      {
         argument_nom = d_faux;          argument_nom = d_faux;
           variable_partagee = d_faux;
     }      }
           
 /*  /*
Line 691  instruction_con(struct_processus *s_etat Line 617  instruction_con(struct_processus *s_etat
             {              {
                 liberation(s_etat_processus, s_objet_2);                  liberation(s_etat_processus, s_objet_2);
             }              }
               else
               {
                   if (variable_partagee == d_vrai)
                   {
                       if (pthread_mutex_unlock(&((*(*s_etat_processus)
                               .pointeur_variable_partagee_courante).mutex)) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
                   }
               }
   
             (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;              (*s_etat_processus).erreur_execution = d_ex_dimensions_invalides;
             return;              return;
Line 711  instruction_con(struct_processus *s_etat Line 649  instruction_con(struct_processus *s_etat
                 {                  {
                     liberation(s_etat_processus, s_objet_2);                      liberation(s_etat_processus, s_objet_2);
                 }                  }
                   else
                   {
                       if (variable_partagee == d_vrai)
                       {
                           if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                   .pointeur_variable_partagee_courante).mutex))
                                   != 0)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
                       }
                   }
   
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_type_argument;                          d_ex_erreur_type_argument;
Line 725  instruction_con(struct_processus *s_etat Line 676  instruction_con(struct_processus *s_etat
                 {                  {
                     liberation(s_etat_processus, s_objet_2);                      liberation(s_etat_processus, s_objet_2);
                 }                  }
                   else
                   {
                       if (variable_partagee == d_vrai)
                       {
                           if (pthread_mutex_unlock(&((*(*s_etat_processus)
                                   .pointeur_variable_partagee_courante).mutex))
                                   != 0)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
                       }
                   }
   
                 (*s_etat_processus).erreur_execution = d_ex_argument_invalide;                  (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
                 return;                  return;
Line 782  instruction_con(struct_processus *s_etat Line 746  instruction_con(struct_processus *s_etat
         {          {
             liberation(s_etat_processus, s_objet_2);              liberation(s_etat_processus, s_objet_2);
         }          }
           else
           {
               if (variable_partagee == d_vrai)
               {
                   if (pthread_mutex_unlock(&((*(*s_etat_processus)
                           .pointeur_variable_partagee_courante).mutex)) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
               }
           }
   
         liberation(s_etat_processus, s_objet_1);          liberation(s_etat_processus, s_objet_1);
   
Line 803  instruction_con(struct_processus *s_etat Line 779  instruction_con(struct_processus *s_etat
         {          {
             liberation(s_etat_processus, s_objet_2);              liberation(s_etat_processus, s_objet_2);
         }          }
           else
           {
               if (variable_partagee == d_vrai)
               {
                   if (pthread_mutex_unlock(&((*(*s_etat_processus)
                           .pointeur_variable_partagee_courante).mutex)) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
               }
           }
   
         liberation(s_etat_processus, s_objet_1);          liberation(s_etat_processus, s_objet_1);
   
Line 829  instruction_con(struct_processus *s_etat Line 817  instruction_con(struct_processus *s_etat
                     nombre_lignes;                      nombre_lignes;
   
             if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =              if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                     malloc(nombre_lignes * sizeof(integer8))) == NULL)                      malloc(((size_t) nombre_lignes) * sizeof(integer8)))
                       == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 855  instruction_con(struct_processus *s_etat Line 844  instruction_con(struct_processus *s_etat
                     nombre_lignes;                      nombre_lignes;
   
             if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =              if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                     malloc(nombre_lignes * sizeof(real8))) == NULL)                      malloc(((size_t) nombre_lignes) * sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 881  instruction_con(struct_processus *s_etat Line 870  instruction_con(struct_processus *s_etat
                     nombre_lignes;                      nombre_lignes;
   
             if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =              if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                     malloc(nombre_lignes * sizeof(struct_complexe16))) == NULL)                      malloc(((size_t) nombre_lignes) *
                       sizeof(struct_complexe16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 921  instruction_con(struct_processus *s_etat Line 911  instruction_con(struct_processus *s_etat
                     nombre_colonnes;                      nombre_colonnes;
   
             if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =              if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                     malloc(nombre_lignes * sizeof(integer8 *))) == NULL)                      malloc(((size_t) nombre_lignes) * sizeof(integer8 *)))
                       == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 930  instruction_con(struct_processus *s_etat Line 921  instruction_con(struct_processus *s_etat
             for(i = 0; i < nombre_lignes; i++)              for(i = 0; i < nombre_lignes; i++)
             {              {
                 if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)                  if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
                         .objet)).tableau)[i] = malloc(                          .objet)).tableau)[i] = malloc(((size_t)
                         nombre_colonnes * sizeof(integer8))) == NULL)                          nombre_colonnes) * sizeof(integer8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 961  instruction_con(struct_processus *s_etat Line 952  instruction_con(struct_processus *s_etat
                     nombre_colonnes;                      nombre_colonnes;
   
             if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =              if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                     malloc(nombre_lignes * sizeof(real8 *))) == NULL)                      malloc(((size_t) nombre_lignes) * sizeof(real8 *))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 970  instruction_con(struct_processus *s_etat Line 961  instruction_con(struct_processus *s_etat
             for(i = 0; i < nombre_lignes; i++)              for(i = 0; i < nombre_lignes; i++)
             {              {
                 if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)                  if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
                         .objet)).tableau)[i] = malloc(                          .objet)).tableau)[i] = malloc(((size_t)
                         nombre_colonnes * sizeof(real8))) == NULL)                          nombre_colonnes) * sizeof(real8))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 1001  instruction_con(struct_processus *s_etat Line 992  instruction_con(struct_processus *s_etat
                     nombre_colonnes;                      nombre_colonnes;
   
             if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =              if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                     malloc(nombre_lignes * sizeof(struct_complexe16 *)))                      malloc(((size_t) nombre_lignes) *
                     == NULL)                      sizeof(struct_complexe16 *))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 1012  instruction_con(struct_processus *s_etat Line 1003  instruction_con(struct_processus *s_etat
             {              {
                 if ((((struct_complexe16 **) (*((struct_matrice *)                  if ((((struct_complexe16 **) (*((struct_matrice *)
                         (*s_objet_resultat).objet)).tableau)[i] =                          (*s_objet_resultat).objet)).tableau)[i] =
                         malloc(nombre_colonnes *                          malloc(((size_t) nombre_colonnes) *
                         sizeof(struct_complexe16))) == NULL)                          sizeof(struct_complexe16))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 1048  instruction_con(struct_processus *s_etat Line 1039  instruction_con(struct_processus *s_etat
     }      }
     else      else
     {      {
         (*(*s_etat_processus).pointeur_variable_courante).objet =          if (variable_partagee == d_vrai)
                 s_objet_resultat;          {
               (*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
                       s_objet_resultat;
   
               if (pthread_mutex_unlock(&((*(*s_etat_processus)
                       .pointeur_variable_partagee_courante).mutex)) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
           }
           else
           {
               (*(*s_etat_processus).pointeur_variable_courante).objet =
                       s_objet_resultat;
           }
     }      }
   
     return;      return;
Line 1188  instruction_cross(struct_processus *s_et Line 1194  instruction_cross(struct_processus *s_et
                 .tableau)[2]), &(((integer8 *) (*((struct_vecteur *)                  .tableau)[2]), &(((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[1]), &(tampon_2));                  (*s_objet_argument_1).objet)).tableau)[1]), &(tampon_2));
   
         tampon_2 = -tampon_2;          depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
   
         depassement |= depassement_addition(&(tampon_1), &(tampon_2),  
                 &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)                  &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
                 .objet)).tableau)[0]));                  .objet)).tableau)[0]));
   
Line 1204  instruction_cross(struct_processus *s_et Line 1208  instruction_cross(struct_processus *s_et
                 .tableau)[0]), &(((integer8 *) (*((struct_vecteur *)                  .tableau)[0]), &(((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[2]), &(tampon_2));                  (*s_objet_argument_1).objet)).tableau)[2]), &(tampon_2));
   
         tampon_2 = -tampon_2;          depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
   
         depassement |= depassement_addition(&(tampon_1), &(tampon_2),  
                 &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)                  &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
                 .objet)).tableau)[1]));                  .objet)).tableau)[1]));
   
Line 1220  instruction_cross(struct_processus *s_et Line 1222  instruction_cross(struct_processus *s_et
                 .tableau)[1]), &(((integer8 *) (*((struct_vecteur *)                  .tableau)[1]), &(((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[0]), &(tampon_2));                  (*s_objet_argument_1).objet)).tableau)[0]), &(tampon_2));
   
         tampon_2 = -tampon_2;          depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
   
         depassement |= depassement_addition(&(tampon_1), &(tampon_2),  
                 &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)                  &(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
                 .objet)).tableau)[2]));                  .objet)).tableau)[2]));
   
Line 1304  instruction_cross(struct_processus *s_et Line 1304  instruction_cross(struct_processus *s_et
         }          }
   
         ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))          ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
                 .tableau)[0] = (((integer8 *) (*((struct_vecteur *)                  .tableau)[0] = ((real8) ((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_2).objet)).tableau)[1] * ((real8 *)                  (*s_objet_argument_2).objet)).tableau)[1] * ((real8 *)
                 (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[2])                  (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[2])
                 - (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2)                  - ((real8) ((integer8 *) (*((struct_vecteur *)
                 .objet)).tableau)[2] * ((real8 *) (*((struct_vecteur *)                  (*s_objet_argument_2).objet)).tableau)[2] *
                   ((real8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[1]);                  (*s_objet_argument_1).objet)).tableau)[1]);
         ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))          ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
                 .tableau)[1] = (((integer8 *) (*((struct_vecteur *)                  .tableau)[1] = ((real8) ((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_2).objet)).tableau)[2] * ((real8 *)                  (*s_objet_argument_2).objet)).tableau)[2] * ((real8 *)
                 (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[0])                  (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[0])
                 - (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2)                  - ((real8) ((integer8 *) (*((struct_vecteur *)
                 .objet)).tableau)[0] * ((real8 *) (*((struct_vecteur *)                  (*s_objet_argument_2) .objet)).tableau)[0] *
                   ((real8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[2]);                  (*s_objet_argument_1).objet)).tableau)[2]);
         ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))          ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
                 .tableau)[2] = (((integer8 *) (*((struct_vecteur *)                  .tableau)[2] = ((real8) ((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_2).objet)).tableau)[0] * ((real8 *)                  (*s_objet_argument_2).objet)).tableau)[0] * ((real8 *)
                 (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[1])                  (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[1])
                 - (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2)                  - ((real8) ((integer8 *) (*((struct_vecteur *)
                 .objet)).tableau)[1] * ((real8 *) (*((struct_vecteur *)                  (*s_objet_argument_2).objet)).tableau)[1] *
                   ((real8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[0]);                  (*s_objet_argument_1).objet)).tableau)[0]);
     }      }
     else if (((*s_objet_argument_1).type == VIN) &&      else if (((*s_objet_argument_1).type == VIN) &&
Line 1357  instruction_cross(struct_processus *s_et Line 1360  instruction_cross(struct_processus *s_et
   
         ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))          ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
                 .tableau)[0] = (((real8 *) (*((struct_vecteur *)                  .tableau)[0] = (((real8 *) (*((struct_vecteur *)
                 (*s_objet_argument_2).objet)).tableau)[1] * ((integer8 *)                  (*s_objet_argument_2).objet)).tableau)[1] * (real8)
                 (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[2])                  ((integer8 *) (*((struct_vecteur *)
                   (*s_objet_argument_1).objet)).tableau)[2])
                 - (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)                  - (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
                 .objet)).tableau)[2] * ((integer8 *) (*((struct_vecteur *)                  .objet)).tableau)[2] * (real8) ((integer8 *)
                   (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[1]);                  (*s_objet_argument_1).objet)).tableau)[1]);
         ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))          ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
                 .tableau)[1] = (((real8 *) (*((struct_vecteur *)                  .tableau)[1] = (((real8 *) (*((struct_vecteur *)
                 (*s_objet_argument_2).objet)).tableau)[2] * ((integer8 *)                  (*s_objet_argument_2).objet)).tableau)[2] * (real8)
                 (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[0])                  ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
                 - (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)                  .objet)).tableau)[0]) - (((real8 *) (*((struct_vecteur *)
                 .objet)).tableau)[0] * ((integer8 *) (*((struct_vecteur *)                  (*s_objet_argument_2) .objet)).tableau)[0] * (real8)
                   ((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[2]);                  (*s_objet_argument_1).objet)).tableau)[2]);
         ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))          ((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
                 .tableau)[2] = (((real8 *) (*((struct_vecteur *)                  .tableau)[2] = (((real8 *) (*((struct_vecteur *)
                 (*s_objet_argument_2).objet)).tableau)[0] * ((integer8 *)                  (*s_objet_argument_2).objet)).tableau)[0] * (real8)
                 (*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[1])                  ((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
                 - (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)                  .objet)).tableau)[1]) - (((real8 *) (*((struct_vecteur *)
                 .objet)).tableau)[1] * ((integer8 *) (*((struct_vecteur *)                  (*s_objet_argument_2) .objet)).tableau)[1] * (real8)
                   ((integer8 *) (*((struct_vecteur *)
                 (*s_objet_argument_1).objet)).tableau)[0]);                  (*s_objet_argument_1).objet)).tableau)[0]);
     }      }
     else if (((*s_objet_argument_1).type == VRL) &&      else if (((*s_objet_argument_1).type == VRL) &&

Removed from v.1.31  
changed lines
  Added in v.1.71


CVSweb interface <joel.bertrand@systella.fr>