[BACK]Return to interface_cas.cpp CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/interface_cas.cpp between versions 1.11 and 1.12

version 1.11, 2011/07/25 07:44:59 version 1.12, 2011/08/03 09:26:47
Line 50  static unsigned char * Line 50  static unsigned char *
 conversion_rpl_vers_cas(struct_processus *s_etat_processus,  conversion_rpl_vers_cas(struct_processus *s_etat_processus,
         struct_objet **s_objet)          struct_objet **s_objet)
 {  {
       logical1                drapeau;
   
     struct_liste_chainee    *l_element_courant;      struct_liste_chainee    *l_element_courant;
       struct_liste_chainee    *l_element_precedent;
   
     struct_objet            *s_objet_temporaire;      struct_objet            *s_objet_temporaire;
   
     t_8_bits                registre[8];      t_8_bits                registre[8];
   
     unsigned char           *resultat;      unsigned char           *resultat;
       unsigned char           *index;
   
     for(int i = 0; i < 8; i++)      for(int i = 0; i < 8; i++)
     {      {
         registre[i] = s_etat_processus->drapeaux_etat[i];          registre[i] = s_etat_processus->drapeaux_etat[i];
     }      }
   
       sf(s_etat_processus, 35);
     cf(s_etat_processus, 48);      cf(s_etat_processus, 48);
     cf(s_etat_processus, 49);      cf(s_etat_processus, 49);
     cf(s_etat_processus, 50);      cf(s_etat_processus, 50);
Line 76  conversion_rpl_vers_cas(struct_processus Line 81  conversion_rpl_vers_cas(struct_processus
     // les noms de fonction. Les fonctions ne peuvent apparaître que dans le      // les noms de fonction. Les fonctions ne peuvent apparaître que dans le
     // cas d'un objet de type ALG.      // cas d'un objet de type ALG.
   
     if ((*s_objet)->type == ALG)      if ((*s_objet)->type == NOM)
     {      {
         if ((*s_objet)->nombre_occurrences > 1)          if (strcmp((const char *) reinterpret_cast<unsigned char *>(
                   reinterpret_cast<struct_nom *>((*s_objet)->objet)->nom),
                   "infinity") == 0)
         {          {
             if ((s_objet_temporaire = copie_objet(s_etat_processus,              if (evaluation(s_etat_processus, *s_objet, 'N') == d_erreur)
                     (*s_objet), 'O')) == NULL)              {
                   return(NULL);
               }
   
               liberation(s_etat_processus, *s_objet);
   
               if (depilement(s_etat_processus, &(s_etat_processus
                       ->l_base_pile), s_objet) == d_erreur)
               {
                   return(NULL);
               }
           }
       }
       else if ((*s_objet)->type == ALG)
       {
           if ((s_objet_temporaire = copie_objet(s_etat_processus,
                   (*s_objet), 'O')) == NULL)
           {
               s_etat_processus->erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
           liberation(s_etat_processus, (*s_objet));
           (*s_objet) = s_objet_temporaire;
   
           // Si l'expression contient la fonction infinity, on commence par
           // forcer une évaluation numérique.
   
           l_element_courant = reinterpret_cast<struct_liste_chainee *>(
                   (*s_objet)->objet);
           drapeau = d_faux;
   
           while(l_element_courant != NULL)
           {
               if (l_element_courant->donnee->type == NOM)
               {
                   if (strcmp((const char *) reinterpret_cast<unsigned char *>(
                           reinterpret_cast<struct_nom *>(
                           l_element_courant->donnee->objet)->nom),
                           "infinity") == 0)
                   {
                       drapeau = d_vrai;
                       break;
                   }
               }
   
               l_element_courant = l_element_courant->suivant;
           }
   
           if (drapeau == d_vrai)
           {
               if (evaluation(s_etat_processus, *s_objet, 'N') == d_erreur)
             {              {
                 s_etat_processus->erreur_systeme = d_es_allocation_memoire;  
                 return(NULL);                  return(NULL);
             }              }
   
             liberation(s_etat_processus, (*s_objet));              liberation(s_etat_processus, *s_objet);
             (*s_objet) = s_objet_temporaire;  
               if (depilement(s_etat_processus, &(s_etat_processus
                       ->l_base_pile), s_objet) == d_erreur)
               {
                   return(NULL);
               }
         }          }
       }
   
       if ((*s_objet)->type == ALG)
       {
   
         l_element_courant = reinterpret_cast<struct_liste_chainee *>(          l_element_courant = reinterpret_cast<struct_liste_chainee *>(
                 (*s_objet)->objet);                  (*s_objet)->objet);
Line 118  conversion_rpl_vers_cas(struct_processus Line 184  conversion_rpl_vers_cas(struct_processus
                 }                  }
             }              }
   
               l_element_precedent = l_element_courant;
             l_element_courant = l_element_courant->suivant;              l_element_courant = l_element_courant->suivant;
         }          }
     }      }
   
     resultat = formateur(s_etat_processus, 0, (*s_objet));      resultat = formateur(s_etat_processus, 0, (*s_objet));
     resultat[0] = ' ';  
     resultat[strlen((const char *) resultat) - 1] = ' ';      // Il faut remplacer les occurrences de 'relax' par '    +'.
   
       index = resultat;
       while((index = reinterpret_cast<unsigned char *>(
               strstr(reinterpret_cast<char *>(index),
               (const char *) "relax"))) != NULL)
       {
           strncpy(reinterpret_cast<char *>(index), "    +", 5);
       }
   
       // Si le résultat vaut infinity, on rajoute le signe +.
   
       if (strcmp(reinterpret_cast<char *>(resultat), "infinity") == 0)
       {
           if ((resultat = reinterpret_cast<unsigned char *>(
                   realloc(resultat, (strlen(reinterpret_cast<char *>(
                   resultat)) + 2) * sizeof(unsigned char)))) == NULL)
           {
               s_etat_processus->erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
           strcpy(reinterpret_cast<char *>(resultat), "+infinity");
       }
   
       if (resultat[0] == '\'')
       {
           resultat[0] = ' ';
           resultat[strlen((const char *) resultat) - 1] = ' ';
       }
   
     for(int i = 0; i < 8; i++)      for(int i = 0; i < 8; i++)
     {      {
Line 158  conversion_cas_vers_rpl(struct_processus Line 254  conversion_cas_vers_rpl(struct_processus
                 // qui n'est pas reconnu comme un mot-clef du RPL/2. S'il                  // qui n'est pas reconnu comme un mot-clef du RPL/2. S'il
                 // s'agit d'un mot-clef de GIAC, on le convertit.                  // s'agit d'un mot-clef de GIAC, on le convertit.
   
                 if (strcmp((const char *)                  if ((strcmp((const char *)
                           reinterpret_cast<struct_fonction *>(l_element_courant
                           ->donnee->objet)->nom_fonction, "quote") == 0) ||
                           (strcmp((const char *)
                         reinterpret_cast<struct_fonction *>(l_element_courant                          reinterpret_cast<struct_fonction *>(l_element_courant
                         ->donnee->objet)->nom_fonction, "quote") == 0)                          ->donnee->objet)->nom_fonction, "nop") == 0))
                 {                  {
                     liberation(s_etat_processus, l_element_courant->donnee);                      liberation(s_etat_processus, l_element_courant->donnee);
   
Line 218  interface_cas(struct_processus *s_etat_p Line 317  interface_cas(struct_processus *s_etat_p
 #   ifdef RPLCAS  #   ifdef RPLCAS
     struct_objet            *s_objet_argument_1;      struct_objet            *s_objet_argument_1;
     struct_objet            *s_objet_argument_2;      struct_objet            *s_objet_argument_2;
       struct_objet            *s_objet_temporaire;
   
       struct_liste_chainee    *l_element_courant;
   
     unsigned char           *argument_1;      unsigned char           *argument_1;
     unsigned char           *argument_2;      unsigned char           *argument_2;
       unsigned char           *argument_3;
       unsigned char           *argument_4;
     unsigned char           *registre;      unsigned char           *registre;
   
       unsigned int            position;
   
     switch(commande)      switch(commande)
     {      {
         case RPLCAS_INTEGRATION:          case RPLCAS_INTEGRATION:
Line 230  interface_cas(struct_processus *s_etat_p Line 336  interface_cas(struct_processus *s_etat_p
             if (depilement(s_etat_processus, &(s_etat_processus->l_base_pile),              if (depilement(s_etat_processus, &(s_etat_processus->l_base_pile),
                     &s_objet_argument_1) == d_erreur)                      &s_objet_argument_1) == d_erreur)
             {              {
                 (*s_etat_processus).erreur_execution = d_ex_manque_argument;                  s_etat_processus->erreur_execution = d_ex_manque_argument;
                 return;                  return;
             }              }
   
Line 238  interface_cas(struct_processus *s_etat_p Line 344  interface_cas(struct_processus *s_etat_p
                     &s_objet_argument_2) == d_erreur)                      &s_objet_argument_2) == d_erreur)
             {              {
                 liberation(s_etat_processus, s_objet_argument_1);                  liberation(s_etat_processus, s_objet_argument_1);
                 (*s_etat_processus).erreur_execution = d_ex_manque_argument;                  s_etat_processus->erreur_execution = d_ex_manque_argument;
                 return;                  return;
             }              }
   
Line 305  interface_cas(struct_processus *s_etat_p Line 411  interface_cas(struct_processus *s_etat_p
   
         case RPLCAS_LIMITE:          case RPLCAS_LIMITE:
         {          {
               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;
               }
   
               // Fonction
   
               if ((argument_2 = conversion_rpl_vers_cas(s_etat_processus,
                       &s_objet_argument_2)) == NULL)
               {
                   s_etat_processus->erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               // On parcourt la liste. Cette liste est tout d'abord copiée
               // car on est susceptible de modifier le second élément.
   
               if ((s_objet_temporaire = copie_objet(s_etat_processus,
                       s_objet_argument_1, 'O')) == NULL)
               {
                   s_etat_processus->erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               liberation(s_etat_processus, s_objet_argument_1);
               s_objet_argument_1 = s_objet_temporaire;
   
               l_element_courant = reinterpret_cast<struct_liste_chainee *>
                       (s_objet_argument_1->objet);
               position = 1;
               argument_4 = NULL;
   
               while(l_element_courant != NULL)
               {
                   switch(position)
                   {
                       case 1:
                       {
                           // Variable
   
                           if ((argument_1 = reinterpret_cast<unsigned char *>
                                   (malloc((strlen((const char *)
                                   ((struct_variable *) (l_element_courant
                                   ->donnee->objet))->nom)
                                   + 1) * sizeof(unsigned char)))) == NULL)
                           {
                               s_etat_processus->erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           strcpy(reinterpret_cast<char *>(argument_1),
                                   (const char *) ((struct_variable *)
                                   (l_element_courant->donnee->objet))->nom);
                           break;
                       }
   
                       case 2:
                       {
                           // Valeur
                           if ((argument_3 = conversion_rpl_vers_cas(
                                   s_etat_processus,
                                   &(l_element_courant->donnee))) == NULL)
                           {
                               s_etat_processus->erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           break;
                       }
   
                       case 3:
                       {
                           // Direction
   
                           if ((argument_4 = reinterpret_cast<unsigned char *>
                                   (malloc((strlen((const char *)
                                   ((struct_fonction *) (l_element_courant
                                   ->donnee->objet))->nom_fonction)
                                   + 1) * sizeof(unsigned char)))) == NULL)
                           {
                               s_etat_processus->erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           strcpy(reinterpret_cast<char *>(argument_4),
                                   (const char *) ((struct_fonction *)
                                   (l_element_courant->donnee->objet))
                                   ->nom_fonction);
                           break;
                       }
                   }
   
                   l_element_courant = (*l_element_courant).suivant;
                   position++;
               }
   
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               try
               {
                   giac::context   contexte;
   
                   int             direction;
   
                   if (argument_4 == NULL)
                   {
                       direction = 0;
                   }
                   else
                   {
                       direction = (strcmp((const char *) argument_4, "+") == 0)
                               ? 1 : -1;
                   }
   
                   gen expression(
                           string(reinterpret_cast<const char *>(argument_2)),
                           &contexte);
                   identificateur variable(
                           string(reinterpret_cast<const char *>(argument_1)));
                   gen valeur(string(reinterpret_cast<const char *>
                           (argument_3)), &contexte);
   
                   gen resultat = limit(expression, variable, valeur, direction,
                           &contexte);
                   string chaine = "'" + resultat.print() + "'";
   
                   registre = s_etat_processus->instruction_courante;
                   s_etat_processus->instruction_courante =
                           reinterpret_cast<unsigned char *>(const_cast<char *>
                           (chaine.c_str()));
   
                   recherche_type(s_etat_processus);
   
                   if (s_etat_processus->l_base_pile != NULL)
                   {
                       conversion_cas_vers_rpl(s_etat_processus,
                               s_etat_processus->l_base_pile->donnee);
                   }
   
                   s_etat_processus->instruction_courante = registre;
               }
               catch(bad_alloc exception)
               {
                   s_etat_processus->erreur_systeme = d_es_allocation_memoire;
               }
               catch(...)
               {
                   s_etat_processus->erreur_execution = d_ex_erreur_interne_rplcas;
               }
   
               free(argument_1);
               free(argument_2);
               free(argument_3);
   
               if (argument_4 != NULL)
               {
                   free(argument_4);
               }
   
             break;              break;
         }          }
     }      }
Removed from v.1.11  
changed lines
  Added in v.1.12

CVSweb interface <joel.bertrand@systella.fr>