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

Diff for /rpl/src/instructions_r7.c between versions 1.4 and 1.48

version 1.4, 2011/12/07 12:25:26 version 1.48, 2020/01/10 11:15:48
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.5    RPL/2 (R) version 4.1.32
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2020 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 74  instruction_restart(struct_processus *s_ Line 74  instruction_restart(struct_processus *s_
     }      }
   
     envoi_signal_processus((*s_etat_processus).pid_processus_pere,      envoi_signal_processus((*s_etat_processus).pid_processus_pere,
             rpl_sigabort);              rpl_sigabort, d_faux);
     (*s_etat_processus).requete_arret = 'Y';      (*s_etat_processus).requete_arret = 'Y';
   
     attente.tv_sec = 0;      attente.tv_sec = 0;
Line 112  instruction_restart(struct_processus *s_ Line 112  instruction_restart(struct_processus *s_
 void  void
 instruction_regex(struct_processus *s_etat_processus)  instruction_regex(struct_processus *s_etat_processus)
 {  {
       integer8                        longueur;
   
     regex_t                         expression;      regex_t                         expression;
   
     struct_liste_chainee            *l_element_courant_ecriture;      struct_liste_chainee            *l_element_courant_ecriture;
Line 121  instruction_regex(struct_processus *s_et Line 123  instruction_regex(struct_processus *s_et
     struct_objet                    *s_objet_argument_2;      struct_objet                    *s_objet_argument_2;
     struct_objet                    *s_objet_resultat;      struct_objet                    *s_objet_resultat;
   
       unsigned char                   *exp;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     if ((*s_etat_processus).affichage_arguments == 'Y')      if ((*s_etat_processus).affichage_arguments == 'Y')
Line 136  instruction_regex(struct_processus *s_et Line 140  instruction_regex(struct_processus *s_et
             printf("(regular expression)\n\n");              printf("(regular expression)\n\n");
         }          }
   
         printf("    1: %s, %s\n", d_LST);          printf("    2: %s\n", d_LST);
           printf("    1: %s\n", d_CHN);
         printf("->  1: %s\n\n", d_LST);          printf("->  1: %s\n\n", d_LST);
   
           printf("    2: %s\n", d_CHN);
         printf("    1: %s\n", d_CHN);          printf("    1: %s\n", d_CHN);
         printf("->  1: %s (0 or -1)\n", d_INT);          printf("->  1: %s (0 or -1)\n", d_INT);
   
Line 146  instruction_regex(struct_processus *s_et Line 152  instruction_regex(struct_processus *s_et
     }      }
     else if ((*s_etat_processus).test_instruction == 'Y')      else if ((*s_etat_processus).test_instruction == 'Y')
     {      {
         (*s_etat_processus).nombre_arguments = 2;          (*s_etat_processus).nombre_arguments = -1;
         return;          return;
     }      }
   
Line 179  instruction_regex(struct_processus *s_et Line 185  instruction_regex(struct_processus *s_et
     {      {
         // Renvoie 0 ou -1          // Renvoie 0 ou -1
   
         if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet,          if ((exp = formateur_flux(s_etat_processus, (*s_objet_argument_1).objet,
                   &longueur)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (regcomp(&expression, (const char *) exp,
                 REG_EXTENDED | REG_NOSUB) != 0)                  REG_EXTENDED | REG_NOSUB) != 0)
         {          {
             liberation(s_etat_processus, s_objet_argument_1);              liberation(s_etat_processus, s_objet_argument_1);
Line 206  instruction_regex(struct_processus *s_et Line 219  instruction_regex(struct_processus *s_et
         }          }
   
         regfree(&expression);          regfree(&expression);
           free(exp);
     }      }
     else if (((*s_objet_argument_1).type == CHN) &&      else if (((*s_objet_argument_1).type == CHN) &&
             ((*s_objet_argument_2).type == LST))              ((*s_objet_argument_2).type == LST))
     {      {
         // Renvoie une liste de chaînes qui correspondent          // Renvoie une liste de chaînes qui correspondent
   
         if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet,          if ((exp = formateur_flux(s_etat_processus, (*s_objet_argument_1).objet,
                   &longueur)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (regcomp(&expression, (const char *) exp,
                 REG_EXTENDED | REG_NOSUB) != 0)                  REG_EXTENDED | REG_NOSUB) != 0)
         {          {
             liberation(s_etat_processus, s_objet_argument_1);              liberation(s_etat_processus, s_objet_argument_1);
Line 304  instruction_regex(struct_processus *s_et Line 325  instruction_regex(struct_processus *s_et
         }          }
   
         regfree(&expression);          regfree(&expression);
           free(exp);
     }      }
     else      else
     {      {
Line 319  instruction_regex(struct_processus *s_et Line 341  instruction_regex(struct_processus *s_et
   
     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
             s_objet_resultat) == d_erreur)              s_objet_resultat) == d_erreur)
       {
           return;
       }
   
       return;
   }
   
   
   /*
   ================================================================================
     Fonction 'rgdl'
   ================================================================================
     Entrées : pointeur sur une structure struct_processus
   --------------------------------------------------------------------------------
     Sorties :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   void
   instruction_rgdl(struct_processus *s_etat_processus)
   {
       integer8                        i;
       integer8                        l;
   
       struct_objet                    *s_objet_argument_1;
       struct_objet                    *s_objet_argument_2;
       struct_objet                    *s_objet_argument_3;
       struct_objet                    *s_objet_resultat;
   
       unsigned char                   *ptr_e;
       unsigned char                   *ptr_l;
   
       (*s_etat_processus).erreur_execution = d_ex;
   
       if ((*s_etat_processus).affichage_arguments == 'Y')
       {
           printf("\n  RGDL ");
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("(fer à droite)\n\n");
           }
           else
           {
               printf("(ragged left)\n\n");
           }
   
           printf("    3: %s\n", d_CHN);
           printf("    2: %s\n", d_INT);
           printf("    1: %s\n", d_CHN);
           printf("->  1: %s\n", d_CHN);
   
           return;
       }
       else if ((*s_etat_processus).test_instruction == 'Y')
       {
           (*s_etat_processus).nombre_arguments = -1;
           return;
       }
   
       if (test_cfsf(s_etat_processus, 31) == d_vrai)
       {
           if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
           {
               return;
           }
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_1) == d_erreur)
       {
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_2) == d_erreur)
       {
           liberation(s_etat_processus, s_objet_argument_1);
   
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_3) == d_erreur)
       {
           liberation(s_etat_processus, s_objet_argument_1);
           liberation(s_etat_processus, s_objet_argument_2);
   
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (((*s_objet_argument_1).type == CHN) &&
               ((*s_objet_argument_2).type == INT) &&
               ((*s_objet_argument_3).type == CHN))
       {
           if ((strlen((unsigned char *) (*s_objet_argument_1).objet) != 1) ||
                   ((*((integer8 *) (*s_objet_argument_2).objet)) < 0))
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
               liberation(s_etat_processus, s_objet_argument_3);
   
               (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
               return;
           }
   
           if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (((*s_objet_resultat).objet = malloc(((size_t) ((*((integer8 *)
                   (*s_objet_argument_2).objet)) + 1)) * sizeof(unsigned char)))
                   == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (((l = (integer8) strlen((unsigned char *) (*s_objet_argument_3)
                   .objet))) >= (*((integer8 *) (*s_objet_argument_2).objet)))
           {
               // Recadrage simple
   
               ptr_e = (unsigned char *) (*s_objet_resultat).objet;
               ptr_l = ((unsigned char *) (*s_objet_argument_3).objet)
                       + (l - (*((integer8 *) (*s_objet_argument_2).objet)));
   
               while((*ptr_l) != d_code_fin_chaine)
               {
                   *ptr_e++ = *ptr_l++;
               }
   
               (*ptr_e) = d_code_fin_chaine;
           }
           else
           {
               // Ajout des caractères
   
               ptr_e = (unsigned char *) (*s_objet_resultat).objet;
               ptr_l = (unsigned char *) (*s_objet_argument_3).objet;
   
               for(i = 0; i < (*((integer8 *) (*s_objet_argument_2).objet)) - l;
                       i++)
               {
                   *ptr_e++ = ((unsigned char *) (*s_objet_argument_1).objet)[0];
               }
   
               while((*ptr_l) != d_code_fin_chaine)
               {
                   *ptr_e++ = *ptr_l++;
               }
   
               (*ptr_e) = d_code_fin_chaine;
           }
       }
       else
       {
           liberation(s_etat_processus, s_objet_argument_1);
           liberation(s_etat_processus, s_objet_argument_2);
           liberation(s_etat_processus, s_objet_argument_3);
   
           (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
           return;
       }
   
       liberation(s_etat_processus, s_objet_argument_1);
       liberation(s_etat_processus, s_objet_argument_2);
       liberation(s_etat_processus, s_objet_argument_3);
   
       if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               s_objet_resultat) == d_erreur)
       {
           return;
       }
   
       return;
   }
   
   
   /*
   ================================================================================
     Fonction 'rgdr'
   ================================================================================
     Entrées : pointeur sur une structure struct_processus
   --------------------------------------------------------------------------------
     Sorties :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   void
   instruction_rgdr(struct_processus *s_etat_processus)
   {
       integer8                        i;
       integer8                        l;
   
       struct_objet                    *s_objet_argument_1;
       struct_objet                    *s_objet_argument_2;
       struct_objet                    *s_objet_argument_3;
       struct_objet                    *s_objet_resultat;
   
       unsigned char                   *ptr_e;
       unsigned char                   *ptr_l;
   
       (*s_etat_processus).erreur_execution = d_ex;
   
       if ((*s_etat_processus).affichage_arguments == 'Y')
       {
           printf("\n  RGDR ");
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("(fer à gauche)\n\n");
           }
           else
           {
               printf("(ragged right)\n\n");
           }
   
           printf("    3: %s\n", d_CHN);
           printf("    2: %s\n", d_INT);
           printf("    1: %s\n", d_CHN);
           printf("->  1: %s\n", d_CHN);
   
           return;
       }
       else if ((*s_etat_processus).test_instruction == 'Y')
       {
           (*s_etat_processus).nombre_arguments = -1;
           return;
       }
   
       if (test_cfsf(s_etat_processus, 31) == d_vrai)
       {
           if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
           {
               return;
           }
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_1) == d_erreur)
       {
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_2) == d_erreur)
       {
           liberation(s_etat_processus, s_objet_argument_1);
   
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_3) == d_erreur)
       {
           liberation(s_etat_processus, s_objet_argument_1);
           liberation(s_etat_processus, s_objet_argument_2);
   
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if (((*s_objet_argument_1).type == CHN) &&
               ((*s_objet_argument_2).type == INT) &&
               ((*s_objet_argument_3).type == CHN))
       {
           if ((strlen((unsigned char *) (*s_objet_argument_1).objet) != 1) ||
                   ((*((integer8 *) (*s_objet_argument_2).objet)) < 0))
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
               liberation(s_etat_processus, s_objet_argument_3);
   
               (*s_etat_processus).erreur_execution = d_ex_argument_invalide;
               return;
           }
   
           if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (((*s_objet_resultat).objet = malloc(((size_t) ((*((integer8 *)
                   (*s_objet_argument_2).objet)) + 1)) * sizeof(unsigned char)))
                   == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (((l = (integer8) strlen((unsigned char *) (*s_objet_argument_3)
                   .objet))) >= (*((integer8 *) (*s_objet_argument_2).objet)))
           {
               // Recadrage simple
   
               ptr_e = (unsigned char *) (*s_objet_resultat).objet;
               ptr_l = ((unsigned char *) (*s_objet_argument_3).objet);
   
               for(i = 0; i < (*((integer8 *) (*s_objet_argument_2).objet)); i++)
               {
                   *ptr_e++ = *ptr_l++;
               }
   
               (*ptr_e) = d_code_fin_chaine;
           }
           else
           {
               // Ajout des caractères
   
               ptr_e = (unsigned char *) (*s_objet_resultat).objet;
               ptr_l = (unsigned char *) (*s_objet_argument_3).objet;
   
               while((*ptr_l) != d_code_fin_chaine)
               {
                   *ptr_e++ = *ptr_l++;
               }
   
               for(i = 0; i < (*((integer8 *) (*s_objet_argument_2).objet)) - l;
                       i++)
               {
                   *ptr_e++ = ((unsigned char *) (*s_objet_argument_1).objet)[0];
               }
   
               (*ptr_e) = d_code_fin_chaine;
           }
       }
       else
       {
           liberation(s_etat_processus, s_objet_argument_1);
           liberation(s_etat_processus, s_objet_argument_2);
           liberation(s_etat_processus, s_objet_argument_3);
   
           (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
           return;
       }
   
       liberation(s_etat_processus, s_objet_argument_1);
       liberation(s_etat_processus, s_objet_argument_2);
       liberation(s_etat_processus, s_objet_argument_3);
   
       if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               s_objet_resultat) == d_erreur)
       {
           return;
       }
   
       return;
   }
   
   
   /*
   ================================================================================
     Fonction 'record'
   ================================================================================
     Entrées : pointeur sur une structure struct_processus
   --------------------------------------------------------------------------------
     Sorties :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   static int
   fonction_comparaison(const void *argument_1, const void *argument_2)
   {
       return(strcmp((unsigned char *) (**((struct_objet **) argument_1)).objet,
               (unsigned char *) (**((struct_objet **) argument_2)).objet));
   }
   
   
   void
   instruction_record(struct_processus *s_etat_processus)
   {
       integer8                        i;
   
       struct_objet                    *s_objet_argument_1;
       struct_objet                    *s_objet_argument_2;
       struct_objet                    *s_objet_resultat;
   
       (*s_etat_processus).erreur_execution = d_ex;
   
       if ((*s_etat_processus).affichage_arguments == 'Y')
       {
           printf("\n  RECORD ");
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("(création d'un enregistrement)\n\n");
           }
           else
           {
               printf("(create record)\n\n");
           }
   
           printf("    1: %s\n", d_TAB);
           printf("->  1: %s\n", d_REC);
   
           return;
       }
       else if ((*s_etat_processus).test_instruction == 'Y')
       {
           (*s_etat_processus).nombre_arguments = -1;
           return;
       }
   
       if (test_cfsf(s_etat_processus, 31) == d_vrai)
       {
           if (empilement_pile_last(s_etat_processus, 1) == d_erreur)
           {
               return;
           }
       }
   
       if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               &s_objet_argument_1) == d_erreur)
       {
           (*s_etat_processus).erreur_execution = d_ex_manque_argument;
           return;
       }
   
       if ((*s_objet_argument_1).type == TBL)
       {
           // Vérification des noms
   
           if ((*((struct_tableau *) (*s_objet_argument_1).objet)).nombre_elements
                   == 0)
           {
               (*s_etat_processus).erreur_execution = d_ex_nombre_arguments;
               liberation(s_etat_processus, s_objet_argument_1);
               return;
           }
   
           for(i = 0; i < (*((struct_tableau *) (*s_objet_argument_1).objet))
                   .nombre_elements; i++)
           {
               if ((*(*((struct_tableau *) (*s_objet_argument_1).objet))
                       .elements[i]).type != CHN)
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_argument;
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   return;
               }
           }
   
           // Tri de la table des noms
   
           qsort((*((struct_tableau *) (*s_objet_argument_1).objet)).elements,
                   (size_t) (*((struct_tableau *) (*s_objet_argument_1).objet))
                   .nombre_elements, sizeof(struct_objet *),
                   fonction_comparaison);
   
           // Vérification de l'unicité des noms
   
           for(i = 0; i < (*((struct_tableau *) (*s_objet_argument_1).objet))
                   .nombre_elements - 1; i++)
           {
               if (strcmp((unsigned char *) (*(*((struct_tableau *)
                       (*s_objet_argument_1).objet)).elements[i]).objet,
                       (unsigned char *) (*(*((struct_tableau *)
                       (*s_objet_argument_1).objet)).elements[i + 1]).objet)
                       == 0)
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_argument_invalide;
   
                   liberation(s_etat_processus, s_objet_argument_1);
                   return;
               }
           }
   
           // Allocation de la table des données
   
           if ((s_objet_argument_2 = allocation(s_etat_processus, TBL)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           (*((struct_tableau *) (*s_objet_argument_2).objet)).nombre_elements =
                   (*((struct_tableau *) (*s_objet_argument_1).objet))
                   .nombre_elements;
   
           if (((*((struct_tableau *) (*s_objet_argument_2).objet)).elements =
                   malloc(((size_t) (*((struct_tableau *)
                   (*s_objet_argument_2).objet)).nombre_elements) *
                   sizeof(struct_objet *))) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           for(i = 0; i < (*((struct_tableau *) (*s_objet_argument_2).objet))
                   .nombre_elements; i++)
   
           {
               if (((*((struct_tableau *) (*s_objet_argument_2).objet)).elements[i]
                       = allocation(s_etat_processus, LST)) == NULL)
               {
                   return;
               }
           }
   
           if ((s_objet_resultat = allocation(s_etat_processus, REC)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           (*((struct_record *) (*s_objet_resultat).objet)).noms =
                   s_objet_argument_1;
           (*((struct_record *) (*s_objet_resultat).objet)).donnees =
                   s_objet_argument_2;
       }
       else
       {
           liberation(s_etat_processus, s_objet_argument_1);
   
           (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
           return;
       }
   
       if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               s_objet_resultat) == d_erreur)
     {      {
         return;          return;
     }      }
Removed from v.1.4  
changed lines
  Added in v.1.48

CVSweb interface <joel.bertrand@systella.fr>