[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.1 and 1.2

version 1.1, 2011/11/30 17:21:07 version 1.2, 2011/12/01 15:23:49
Line 96  instruction_restart(struct_processus *s_ Line 96  instruction_restart(struct_processus *s_
     return;      return;
 }  }
   
   
   /*
   ================================================================================
     Fonction 'regex'
   ================================================================================
     Entrées : pointeur sur une structure struct_processus
   --------------------------------------------------------------------------------
     Sorties :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   void
   instruction_regex(struct_processus *s_etat_processus)
   {
       regex_t                         expression;
   
       struct_liste_chainee            *l_element_courant_ecriture;
       struct_liste_chainee            *l_element_courant_lecture;
   
       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  REGEX ");
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("(expression régulière)\n\n");
           }
           else
           {
               printf("(regular expression)\n\n");
           }
   
           printf("    1: %s, %s\n", d_LST);
           printf("->  1: %s\n\n", d_LST);
   
           printf("    1: %s\n", d_CHN);
           printf("->  1: %s (0 or -1)\n", d_INT);
   
           return;
       }
       else if ((*s_etat_processus).test_instruction == 'Y')
       {
           (*s_etat_processus).nombre_arguments = 2;
           return;
       }
   
       if (test_cfsf(s_etat_processus, 31) == d_vrai)
       {
           if (empilement_pile_last(s_etat_processus, 2) == 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 (((*s_objet_argument_1).type == CHN) &&
               ((*s_objet_argument_2).type == CHN))
       {
           // Renvoie 0 ou -1
   
           if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet,
                   REG_EXTENDED | REG_NOSUB) != 0)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_expression_reguliere;
               return;
           }
   
           if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if (regexec(&expression, (const char *) (*s_objet_argument_1).objet,
                   0, NULL, 0) == 0)
           {
               (*((integer8 *) (*s_objet_resultat).objet)) = -1;
           }
           else // REG_NOMATCH
           {
               (*((integer8 *) (*s_objet_resultat).objet)) = 0;
           }
   
           regfree(&expression);
       }
       else if (((*s_objet_argument_1).type == CHN) &&
               ((*s_objet_argument_2).type == LST))
       {
           // Renvoie une liste de chaînes qui correspondent
   
           if (regcomp(&expression, (const char *) (*s_objet_argument_1).objet,
                   REG_EXTENDED | REG_NOSUB) != 0)
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_expression_reguliere;
               return;
           }
   
           if ((s_objet_resultat = allocation(s_etat_processus, LST)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           l_element_courant_lecture = (*s_objet_argument_2).objet;
           l_element_courant_ecriture = NULL;
   
           while(l_element_courant_lecture != NULL)
           {
               if ((*(*l_element_courant_lecture).donnee).type != CHN)
               {
                   liberation(s_etat_processus, s_objet_argument_1);
                   liberation(s_etat_processus, s_objet_argument_2);
                   liberation(s_etat_processus, s_objet_resultat);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_argument;
                   return;
               }
   
               if (regexec(&expression, (const char *)
                       (*(*l_element_courant_lecture).donnee).objet,
                       0, NULL, 0) == 0)
               {
                   if (l_element_courant_ecriture == NULL)
                   {
                       if (((*s_objet_resultat).objet =
                               allocation_maillon(s_etat_processus)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       l_element_courant_ecriture = (*s_objet_resultat).objet;
   
                       if (((*l_element_courant_ecriture).donnee =
                               copie_objet(s_etat_processus,
                               (*l_element_courant_lecture).donnee, 'P'))
                               == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       (*l_element_courant_ecriture).suivant = NULL;
                   }
                   else
                   {
                       if (((*l_element_courant_ecriture).suivant =
                               allocation_maillon(s_etat_processus)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       l_element_courant_ecriture =
                               (*l_element_courant_ecriture).suivant;
   
                       if (((*l_element_courant_ecriture).donnee =
                               copie_objet(s_etat_processus,
                               (*l_element_courant_lecture).donnee, 'P'))
                               == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       (*l_element_courant_ecriture).suivant = NULL;
                   }
               }
   
               l_element_courant_lecture = (*l_element_courant_lecture).suivant;
           }
   
           regfree(&expression);
       }
       else
       {
           liberation(s_etat_processus, s_objet_argument_1);
           liberation(s_etat_processus, s_objet_argument_2);
   
           (*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);
   
       if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
               s_objet_resultat) == d_erreur)
       {
           return;
       }
   
       return;
   }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.1  
changed lines
  Added in v.1.2

CVSweb interface <joel.bertrand@systella.fr>