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

Diff for /rpl/src/analyse_notation_algebrique.c between versions 1.46 and 1.75

version 1.46, 2013/03/23 17:46:28 version 1.75, 2022/09/07 13:40:29
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.34
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2021 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 217  analyse_algebrique(struct_processus *s_e Line 217  analyse_algebrique(struct_processus *s_e
             {              {
                 instruction_test[5] = d_code_fin_chaine;                  instruction_test[5] = d_code_fin_chaine;
   
                 instruction_majuscule = conversion_majuscule(strncpy(                  instruction_majuscule = conversion_majuscule(
                         instruction_test, ptr1, 5));                          s_etat_processus, strncpy(instruction_test, ptr1, 5));
   
                 if (instruction_majuscule == NULL)                  if (instruction_majuscule == NULL)
                 {                  {
Line 241  analyse_algebrique(struct_processus *s_e Line 241  analyse_algebrique(struct_processus *s_e
                     for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);                      for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
                     (*(ptr2++)) = (*ptr1);                      (*(ptr2++)) = (*ptr1);
                 }                  }
                 else if ((strncmp(instruction_majuscule, " OR ", 4) == 0) &&                  else if (strcmp(instruction_majuscule, " EQV ") == 0)
                         (strlen(instruction_majuscule) == 4))                  {
                       for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
                       (*(ptr2++)) = (*ptr1);
                   }
                   else if ((strcmp(instruction_majuscule, " OR ") == 0))
                 {                  {
                     for(i = 0; i < 3; (*(ptr2++)) = (*(ptr1++)), i++);                      for(i = 0; i < 3; (*(ptr2++)) = (*(ptr1++)), i++);
                     (*(ptr2++)) = (*ptr1);                      (*(ptr2++)) = (*ptr1);
Line 358  analyse_algebrique(struct_processus *s_e Line 362  analyse_algebrique(struct_processus *s_e
             if ((drapeau_debut_zone_valide == d_vrai) &&              if ((drapeau_debut_zone_valide == d_vrai) &&
                     (drapeau_fin_zone_valide == d_vrai))                      (drapeau_fin_zone_valide == d_vrai))
             {              {
                 chaine_gauche = purification_chaine(                  chaine_gauche = purification_chaine(s_etat_processus,
                         extraction_chaine(chaine_travail,                          extraction_chaine(s_etat_processus, chaine_travail,
                         1, debut_zone_algebrique));                          1, debut_zone_algebrique));
                 chaine_centrale = purification_chaine(                  chaine_centrale = purification_chaine(s_etat_processus,
                         extraction_chaine(chaine_travail,                          extraction_chaine(s_etat_processus, chaine_travail,
                         debut_zone_algebrique + 1, fin_zone_algebrique + 1));                          debut_zone_algebrique + 1, fin_zone_algebrique + 1));
                 chaine_droite = purification_chaine(                  chaine_droite = purification_chaine(s_etat_processus,
                         extraction_chaine(chaine_travail,                          extraction_chaine(s_etat_processus, chaine_travail,
                         fin_zone_algebrique + 2,                          fin_zone_algebrique + 2,
                         (integer8) strlen(chaine_travail)));                          (integer8) strlen(chaine_travail)));
   
Line 469  analyse_algebrique(struct_processus *s_e Line 473  analyse_algebrique(struct_processus *s_e
                 if ((test_expression_rpn(chaine_centrale) == d_vrai) &&                  if ((test_expression_rpn(chaine_centrale) == d_vrai) &&
                         (fin_zone_algebrique - debut_zone_algebrique > 0))                          (fin_zone_algebrique - debut_zone_algebrique > 0))
                 {                  {
                     if ((tampon = purification_chaine(                      if ((tampon = purification_chaine(s_etat_processus,
                             extraction_chaine(chaine_centrale, 2,                              extraction_chaine(s_etat_processus,
                               chaine_centrale, 2,
                             ((integer8) strlen(chaine_centrale)) - 1))) == NULL)                              ((integer8) strlen(chaine_centrale)) - 1))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 540  analyse_algebrique(struct_processus *s_e Line 545  analyse_algebrique(struct_processus *s_e
                         j--;                          j--;
                     }                      }
   
                     chaine_fonction = purification_chaine(                      chaine_fonction = purification_chaine(s_etat_processus,
                             extraction_chaine(chaine_centrale, 2, i));                              extraction_chaine(s_etat_processus,
                     chaine_arguments = purification_chaine(                              chaine_centrale, 2, i));
                             extraction_chaine(chaine_centrale, i + 2, j));                      chaine_arguments = purification_chaine(s_etat_processus,
                               extraction_chaine(s_etat_processus,
                               chaine_centrale, i + 2, j));
   
                     i = 0;                      i = 0;
                     niveau = 0;                      niveau = 0;
Line 564  analyse_algebrique(struct_processus *s_e Line 571  analyse_algebrique(struct_processus *s_e
                         if ((chaine_arguments[i] == ',') && (niveau == 0))                          if ((chaine_arguments[i] == ',') && (niveau == 0))
                         {                          {
                             sous_chaine_gauche = purification_chaine(                              sous_chaine_gauche = purification_chaine(
                                     extraction_chaine(chaine_arguments, 1, i));                                      s_etat_processus,
                                       extraction_chaine(s_etat_processus,
                                       chaine_arguments, 1, i));
                             sous_chaine_droite = purification_chaine(                              sous_chaine_droite = purification_chaine(
                                     extraction_chaine(chaine_arguments, i + 2,                                      s_etat_processus,
                                       extraction_chaine(s_etat_processus,
                                       chaine_arguments, i + 2,
                                     ((integer8) strlen(chaine_arguments))));                                      ((integer8) strlen(chaine_arguments))));
   
                             free(chaine_arguments);                              free(chaine_arguments);
Line 818  analyse_algebrique(struct_processus *s_e Line 829  analyse_algebrique(struct_processus *s_e
   
                 if ((chaine_travail[i] != 0) && (j != 0))                  if ((chaine_travail[i] != 0) && (j != 0))
                 {                  {
                     chaine_gauche = purification_chaine(                      chaine_gauche = purification_chaine(s_etat_processus,
                             extraction_chaine(chaine_travail, 1, i));                              extraction_chaine(s_etat_processus,
                     chaine_centrale = purification_chaine(                              chaine_travail, 1, i));
                             extraction_chaine(chaine_travail,                      chaine_centrale = purification_chaine(s_etat_processus,
                               extraction_chaine(s_etat_processus, chaine_travail,
                             i + 1, j + 1));                              i + 1, j + 1));
                     chaine_droite = purification_chaine(                      chaine_droite = purification_chaine(s_etat_processus,
                             extraction_chaine(chaine_travail, j + 2,                              extraction_chaine(s_etat_processus, chaine_travail,
                             ((integer8) strlen(chaine_travail))));                              j + 2, ((integer8) strlen(chaine_travail))));
   
                     if ((chaine_gauche == NULL) || (chaine_centrale == NULL) ||                      if ((chaine_gauche == NULL) || (chaine_centrale == NULL) ||
                             (chaine_droite == NULL))                              (chaine_droite == NULL))
Line 940  analyse_algebrique(struct_processus *s_e Line 952  analyse_algebrique(struct_processus *s_e
   
                         if (niveau == 0)                          if (niveau == 0)
                         {                          {
                             prologue = purification_chaine(                              prologue = purification_chaine(s_etat_processus,
                                     extraction_chaine(chaine_centrale, 1, k));                                      extraction_chaine(s_etat_processus,
                             epilogue = purification_chaine(                                      chaine_centrale, 1, k));
                                     extraction_chaine(chaine_centrale,                              epilogue = purification_chaine(s_etat_processus,
                                     k + 2, longueur_chaine));                                      extraction_chaine(s_etat_processus,
                                       chaine_centrale, k + 2, longueur_chaine));
   
                             if ((prologue == NULL) || (epilogue == NULL))                              if ((prologue == NULL) || (epilogue == NULL))
                             {                              {
Line 1029  analyse_algebrique(struct_processus *s_e Line 1042  analyse_algebrique(struct_processus *s_e
                                 drapeau_modification = d_vrai;                                  drapeau_modification = d_vrai;
                             }                              }
                             else if (((priorite == 1) && (t4 == ' ') &&                              else if (((priorite == 1) && (t4 == ' ') &&
                                     (t3 == 'X') && (t2 == 'O') && (t1 == 'R')                                      (((t3 == 'X') && (t2 == 'O') && (t1 == 'R'))
                                     && (t0 == ' ')) || ((priorite == 2) &&                                      || ((t3 == 'E') && (t2 == 'Q') &&
                                       (t1 == 'V'))) && (t0 == ' '))
                                       || ((priorite == 2) &&
                                     (t4 == ' ') && (t3 == 'A') && (t2 == 'N')                                      (t4 == ' ') && (t3 == 'A') && (t2 == 'N')
                                     && (t1 == 'D') && (t0 == ' ')))                                      && (t1 == 'D') && (t0 == ' ')))
                             {                              {
Line 1148  analyse_algebrique(struct_processus *s_e Line 1163  analyse_algebrique(struct_processus *s_e
   
   
 unsigned char *  unsigned char *
 purification_chaine(unsigned char *chaine)  purification_chaine(struct_processus *s_etat_processus, unsigned char *chaine)
 {  {
     integer8                    i;      integer8                    i;
     integer8                    j;      integer8                    j;
   
     unsigned char               *chaine_purifiee;      unsigned char               *chaine_purifiee;
   
       if (chaine == NULL)
       {
           return(NULL);
       }
   
     i = 0;      i = 0;
     j = ((integer8) strlen(chaine)) - 1;      j = ((integer8) strlen(chaine)) - 1;
   
Line 1179  purification_chaine(unsigned char *chain Line 1199  purification_chaine(unsigned char *chain
         }          }
     }      }
   
     chaine_purifiee = extraction_chaine(chaine, i + 1, j + 1);      chaine_purifiee = extraction_chaine(s_etat_processus, chaine, i + 1, j + 1);
     free(chaine);      free(chaine);
   
     return(chaine_purifiee);      return(chaine_purifiee);
Line 1273  test_expression_rpn(unsigned char *chain Line 1293  test_expression_rpn(unsigned char *chain
                 || ((t0 == ' ') && ((t1 == 'A') || (t1 == 'a')) &&                  || ((t0 == ' ') && ((t1 == 'A') || (t1 == 'a')) &&
                 ((t2 == 'N') || (t2 == 'n')) && ((t3 == 'D') || (t3 == 'd'))                  ((t2 == 'N') || (t2 == 'n')) && ((t3 == 'D') || (t3 == 'd'))
                 && (t4 == ' ')) ||                  && (t4 == ' ')) ||
                   ((t0 == ' ') && ((t1 == 'E') || (t1 == 'e')) &&
                   ((t2 == 'Q') || (t2 == 'q')) && ((t3 == 'V') || (t3 == 'v'))
                   && (t4 == ' ')) ||
                 ((t0 == ' ') && ((t1 == 'O') || (t1 == 'o')) &&                  ((t0 == ' ') && ((t1 == 'O') || (t1 == 'o')) &&
                 ((t2 == 'R') || (t2 == 'r')) && (t3 == ' ')) ||                  ((t2 == 'R') || (t2 == 'r')) && (t3 == ' ')) ||
                 ((t0 == ' ') && ((t1 == 'X') || (t1 == 'x')) &&                  ((t0 == ' ') && ((t1 == 'X') || (t1 == 'x')) &&
Line 1358  test_fonction(unsigned char *chaine) Line 1381  test_fonction(unsigned char *chaine)
   
   
 unsigned char *  unsigned char *
 extraction_chaine(unsigned char *chaine, integer8 position_1,  extraction_chaine(struct_processus *s_etat_processus,
         integer8 position_2)          unsigned char *chaine, integer8 position_1, integer8 position_2)
 {  {
     integer8                i;      integer8                i;
   
Line 1384  extraction_chaine(unsigned char *chaine, Line 1407  extraction_chaine(unsigned char *chaine,
             malloc(((size_t) (position_2 - position_1 + 2)) *              malloc(((size_t) (position_2 - position_1 + 2)) *
             sizeof(unsigned char))) == NULL)              sizeof(unsigned char))) == NULL)
     {      {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return(NULL);          return(NULL);
     }      }
   
Removed from v.1.46  
changed lines
  Added in v.1.75

CVSweb interface <joel.bertrand@systella.fr>