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

Diff for /rpl/src/instructions_g2.c between versions 1.41 and 1.76

version 1.41, 2012/12/19 09:58:25 version 1.76, 2023/08/07 17:42:55
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.12    RPL/2 (R) version 4.1.35
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2023 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 35 Line 35
 ================================================================================  ================================================================================
 */  */
   
   static int
   fonction_comparaison(const void *argument_1, const void *argument_2)
   {
       return(strcmp((unsigned char *) argument_1,
               (unsigned char *) (**((struct_objet **) argument_2)).objet));
   }
   
   
 void  void
 instruction_get(struct_processus *s_etat_processus)  instruction_get(struct_processus *s_etat_processus)
 {  {
Line 42  instruction_get(struct_processus *s_etat Line 50  instruction_get(struct_processus *s_etat
   
     struct_liste_chainee                *l_element_courant;      struct_liste_chainee                *l_element_courant;
   
       struct_objet                        **s_enregistrement;
     struct_objet                        *s_objet_1;      struct_objet                        *s_objet_1;
     struct_objet                        *s_objet_2;      struct_objet                        *s_objet_2;
     struct_objet                        *s_objet_3;      struct_objet                        *s_objet_3;
     struct_objet                        *s_objet_element;      struct_objet                        *s_objet_element;
       struct_objet                        *s_objet_noms;
     struct_objet                        *s_objet_resultat;      struct_objet                        *s_objet_resultat;
   
     unsigned long                       indice_i;      integer8                            indice_i;
     unsigned long                       indice_j;      integer8                            indice_j;
     unsigned long                       nombre_dimensions;      integer8                            nombre_dimensions;
   
       unsigned char                       *registre_instruction_courante;
       unsigned char                       registre_instruction_valide;
       unsigned char                       registre_test;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 81  instruction_get(struct_processus *s_etat Line 95  instruction_get(struct_processus *s_etat
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n\n",                  "       %s, %s, %s\n\n",
                   d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                   d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                   d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
           printf("    2: %s\n", d_REC);
           printf("    1: %s\n", d_CHN);
           printf("->  1: %s, %s, %s, %s, %s, %s,\n"
                   "       %s, %s, %s, %s, %s,\n"
                   "       %s, %s, %s, %s, %s,\n"
                   "       %s, %s, %s, %s,\n"
                   "       %s, %s, %s\n\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
         printf("    2: %s, %s\n", d_LST, d_NOM);          printf("    2: %s, %s\n", d_LST, d_NOM);
         printf("    1: %s\n", d_INT);          printf("    1: %s\n", d_INT);
Line 92  instruction_get(struct_processus *s_etat Line 117  instruction_get(struct_processus *s_etat
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
         return;          return;
     }      }
Line 515  instruction_get(struct_processus *s_etat Line 540  instruction_get(struct_processus *s_etat
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Traitement des enregistrements
   --------------------------------------------------------------------------------
   */
   
       else if ((*s_objet_2).type == REC)
       {
           if ((*s_objet_1).type != CHN)
           {
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
   
               (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
               return;
           }
   
           s_objet_noms = (*((struct_record *) (*s_objet_2).objet)).noms;
   
           if ((s_enregistrement = bsearch((unsigned char *) (*s_objet_1).objet,
                   (*((struct_tableau *) (*s_objet_noms).objet)).elements,
                   (size_t) (*((struct_tableau *) (*s_objet_noms).objet))
                   .nombre_elements, sizeof(struct_objet *), fonction_comparaison))
                   == NULL)
           {
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
   
               (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
               return;
           }
   
           indice_i = s_enregistrement - (*((struct_tableau *)
                   (*s_objet_noms).objet)).elements;
   
           // Récupération de l'objet dans le tableau données
   
           if ((s_objet_resultat = copie_objet(s_etat_processus,
                   (*((struct_tableau *) (*(*((struct_record *)
                   (*s_objet_2).objet)).donnees).objet)).elements[indice_i], 'P'))
                   == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
       }
   /*
   --------------------------------------------------------------------------------
   Traitement des variables    Traitement des variables
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 1191  instruction_get(struct_processus *s_etat Line 1262  instruction_get(struct_processus *s_etat
                 return;                  return;
             }              }
         }          }
           else if ((*s_objet_3).type == REC)
           {
               if ((*s_objet_1).type != CHN)
               {
                   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_2);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_argument;
                   return;
               }
   
               s_objet_noms = (*((struct_record *) (*s_objet_3).objet)).noms;
   
               if ((s_enregistrement = bsearch((unsigned char *)
                       (*s_objet_1).objet, (*((struct_tableau *)
                       (*s_objet_noms).objet)).elements,
                       (size_t) (*((struct_tableau *) (*s_objet_noms).objet))
                       .nombre_elements, sizeof(struct_objet *),
                       fonction_comparaison)) == NULL)
               {
                   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_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_element_inexistant;
                   return;
               }
   
               indice_i = s_enregistrement - (*((struct_tableau *)
                       (*s_objet_noms).objet)).elements;
   
               // Récupération de l'objet dans le tableau données
   
               if ((s_objet_resultat = copie_objet(s_etat_processus,
                       (*((struct_tableau *) (*(*((struct_record *)
                       (*s_objet_3).objet)).donnees).objet)).elements[indice_i],
                       'P')) == NULL)
               {
                   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_systeme = d_es_allocation_memoire;
                   return;
               }
           }
         else          else
         {          {
             if (variable_partagee == d_vrai)              if (variable_partagee == d_vrai)
Line 1236  instruction_get(struct_processus *s_etat Line 1379  instruction_get(struct_processus *s_etat
         return;          return;
     }      }
   
     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      liberation(s_etat_processus, s_objet_1);
             s_objet_resultat) == d_erreur)      liberation(s_etat_processus, s_objet_2);
   
       if ((*s_objet_resultat).type == NOM)
     {      {
         return;          if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
           {
               if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
               {
                   return;
               }
           }
           else
           {
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
               {
                   return;
               }
           }
     }      }
       else if ((*s_objet_resultat).type == FCT)
       {
           registre_test = (*s_etat_processus).test_instruction;
           registre_instruction_courante = (*s_etat_processus)
                   .instruction_courante;
           registre_instruction_valide = (*s_etat_processus)
                   .instruction_valide;
   
     liberation(s_etat_processus, s_objet_1);          (*s_etat_processus).test_instruction = 'Y';
     liberation(s_etat_processus, s_objet_2);          (*s_etat_processus).instruction_courante =
                   (*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
   
           analyse(s_etat_processus, NULL);
   
           (*s_etat_processus).test_instruction = registre_test;
           (*s_etat_processus).instruction_courante =
                   registre_instruction_courante;
   
           if (((*s_etat_processus).instruction_valide == 'Y') &&
                   (*s_etat_processus).constante_symbolique == 'Y')
           {
               if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
               {
                   (*s_etat_processus).instruction_valide =
                           registre_instruction_valide;
                   return;
               }
           }
           else
           {
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
               {
                   (*s_etat_processus).instruction_valide =
                           registre_instruction_valide;
                   return;
               }
           }
   
           (*s_etat_processus).instruction_valide = registre_instruction_valide;
       }
       else
       {
           if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                   s_objet_resultat) == d_erreur)
           {
               return;
           }
       }
   
     return;      return;
 }  }
Line 1274  instruction_geti(struct_processus *s_eta Line 1479  instruction_geti(struct_processus *s_eta
     struct_objet                        *s_objet_3;      struct_objet                        *s_objet_3;
     struct_objet                        *s_objet_resultat;      struct_objet                        *s_objet_resultat;
   
     unsigned long                       indice_i;      integer8                            indice_i;
     unsigned long                       indice_j;      integer8                            indice_j;
     unsigned long                       nombre_dimensions;      integer8                            nombre_dimensions;
     unsigned long                       nombre_elements;      integer8                            nombre_elements;
   
       unsigned char                       *registre_instruction_courante;
       unsigned char                       registre_instruction_valide;
       unsigned char                       registre_test;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 1314  instruction_geti(struct_processus *s_eta Line 1523  instruction_geti(struct_processus *s_eta
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s, %s,\n"
                 "       %s, %s, %s, %s,\n"                  "       %s, %s, %s, %s,\n"
                 "       %s, %s\n",                  "       %s, %s, %s\n",
                 d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,                  d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
                 d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,                  d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
                 d_SQL, d_SLB, d_PRC, d_MTX);                  d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
   
         return;          return;
     }      }
Line 2364  instruction_geti(struct_processus *s_eta Line 2573  instruction_geti(struct_processus *s_eta
         return;          return;
     }      }
   
     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if ((*s_objet_resultat).type == NOM)
             s_objet_resultat) == d_erreur)  
     {      {
         return;          if ((*((struct_nom *) (*s_objet_resultat).objet)).symbole == d_faux)
           {
               if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
               {
                   return;
               }
           }
           else
           {
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
               {
                   return;
               }
           }
       }
       else if ((*s_objet_resultat).type == FCT)
       {
           registre_test = (*s_etat_processus).test_instruction;
           registre_instruction_courante = (*s_etat_processus)
                   .instruction_courante;
           registre_instruction_valide = (*s_etat_processus)
                   .instruction_valide;
   
           (*s_etat_processus).test_instruction = 'Y';
           (*s_etat_processus).instruction_courante =
                   (*((struct_fonction *) (*s_objet_resultat).objet)).nom_fonction;
   
           analyse(s_etat_processus, NULL);
   
           (*s_etat_processus).test_instruction = registre_test;
           (*s_etat_processus).instruction_courante =
                   registre_instruction_courante;
   
           if (((*s_etat_processus).instruction_valide == 'Y') &&
                   (*s_etat_processus).constante_symbolique == 'Y')
           {
               if (evaluation(s_etat_processus, s_objet_resultat, 'E') == d_erreur)
               {
                   (*s_etat_processus).instruction_valide =
                           registre_instruction_valide;
                   return;
               }
           }
           else
           {
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
               {
                   (*s_etat_processus).instruction_valide =
                           registre_instruction_valide;
                   return;
               }
           }
   
           (*s_etat_processus).instruction_valide = registre_instruction_valide;
       }
       else
       {
           if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                   s_objet_resultat) == d_erreur)
           {
               return;
           }
     }      }
   
     return;      return;
Removed from v.1.41  
changed lines
  Added in v.1.76

CVSweb interface <joel.bertrand@systella.fr>