[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.12 and 1.71

version 1.12, 2011/08/03 09:26:47 version 1.71, 2024/01/09 07:33:55
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.2    RPL/2 (R) version 4.1.35
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2024 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 21 Line 21
   
   
 #ifdef RPLCAS  #ifdef RPLCAS
 #   include "giac.h"  #   define RPLCXX
   
   // Giac inclut <semaphore.h> et définit sem_t. Or l'émulation
   // des IPCS POSIX requiert une redéfinition de sem_t.
   
   #   ifdef IPCS_SYSV
   //      NetBSD : _SEMAPHORE_H_
   #       define _SEMAPHORE_H_
   //      Linux : _SEMAPHORE_H
   #       define _SEMAPHORE_H
   #   endif
   
   #   pragma GCC diagnostic push
   #   pragma GCC diagnostic ignored "-Wstrict-aliasing"
   #   pragma GCC diagnostic ignored "-Wunused-parameter"
   #   pragma GCC diagnostic ignored "-Wempty-body"
   #   pragma GCC diagnostic ignored "-Wunknown-pragmas"
   #   include "giacPCH.h"
   #   pragma GCC diagnostic pop
   
 #   undef PACKAGE  #   undef PACKAGE
 #   undef PACKAGE_NAME  #   undef PACKAGE_NAME
Line 37  extern "C" Line 55  extern "C"
 #   include "rpl-conv.h"  #   include "rpl-conv.h"
 }  }
   
 #include <iostream>  #ifdef RPLCAS
   #   include <iostream>
   #endif
   
 using namespace std;  using namespace std;
   
Line 45  using namespace std; Line 65  using namespace std;
     using namespace giac;      using namespace giac;
 #endif  #endif
   
   void
   initialisation_contexte_cas(struct_processus *s_etat_processus)
   {
       s_etat_processus->contexte_cas = NULL;
       return;
   }
   
   void
   liberation_contexte_cas(struct_processus *s_etat_processus)
   {
       if (s_etat_processus->contexte_cas != NULL)
       {
   #       ifdef RPLCAS
           delete reinterpret_cast<giac::context *>(
                   s_etat_processus->contexte_cas);
   #       endif
           s_etat_processus->contexte_cas = NULL;
       }
   
       return;
   }
   
   #ifdef RPLCAS
 static unsigned char *  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)
Line 53  conversion_rpl_vers_cas(struct_processus Line 95  conversion_rpl_vers_cas(struct_processus
     logical1                drapeau;      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;
   
Line 94  conversion_rpl_vers_cas(struct_processus Line 135  conversion_rpl_vers_cas(struct_processus
   
             liberation(s_etat_processus, *s_objet);              liberation(s_etat_processus, *s_objet);
   
             if (depilement(s_etat_processus, &(s_etat_processus              if (depilement(s_etat_processus, &(s_etat_processus->l_base_pile),
                     ->l_base_pile), s_objet) == d_erreur)                      s_objet) == d_erreur)
             {              {
                 return(NULL);                  return(NULL);
             }              }
Line 184  conversion_rpl_vers_cas(struct_processus Line 225  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;
         }          }
     }      }
Line 198  conversion_rpl_vers_cas(struct_processus Line 238  conversion_rpl_vers_cas(struct_processus
             strstr(reinterpret_cast<char *>(index),              strstr(reinterpret_cast<char *>(index),
             (const char *) "relax"))) != NULL)              (const char *) "relax"))) != NULL)
     {      {
         strncpy(reinterpret_cast<char *>(index), "    +", 5);          memcpy(reinterpret_cast<char *>(index), "    +", 5);
     }      }
   
     // Si le résultat vaut infinity, on rajoute le signe +.      // Si le résultat vaut infinity, on rajoute le signe +.
Line 233  conversion_rpl_vers_cas(struct_processus Line 273  conversion_rpl_vers_cas(struct_processus
   
 static void  static void
 conversion_cas_vers_rpl(struct_processus *s_etat_processus,  conversion_cas_vers_rpl(struct_processus *s_etat_processus,
         struct_objet *s_objet)          unsigned char *expression)
 {  {
       logical1                    drapeau;
   
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_precedent;  
       struct_objet                *s_objet;
   
       unsigned char               *registre;
   
       registre = s_etat_processus->instruction_courante;
       s_etat_processus->instruction_courante = expression;
       recherche_type(s_etat_processus);
       s_etat_processus->instruction_courante = registre;
   
       if ((s_etat_processus->l_base_pile == NULL) ||
               (s_etat_processus->erreur_execution != d_ex) ||
               (s_etat_processus->erreur_systeme != d_es))
       {
           return;
       }
   
       // Le niveau 1 de la pile opérationnelle contient l'expression
       // à convertir.
   
       if (depilement(s_etat_processus, &(s_etat_processus
               ->l_base_pile), &s_objet) == d_erreur)
       {
           return;
       }
   
     if ((s_objet->type == ALG) || (s_objet->type == RPN))      if ((s_objet->type == ALG) || (s_objet->type == RPN))
     {      {
         // On transcrit les fonctions de GIAC vers le RPL/2.          // On transcrit les fonctions de GIAC vers le RPL/2.
   
         l_element_precedent = NULL;          l_element_courant = reinterpret_cast<struct_liste_chainee *>(
                   s_objet->objet);
           drapeau = d_faux;
   
           // S'il y a une valeur infini, on force l'évaluation de l'expression.
   
           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)
               {
                   return;
               }
   
               liberation(s_etat_processus, s_objet);
   
               if (depilement(s_etat_processus, &(s_etat_processus
                       ->l_base_pile), &s_objet) == d_erreur)
               {
                   return;
               }
           }
       }
   
       if ((s_objet->type == ALG) || (s_objet->type == RPN))
       {
         l_element_courant = reinterpret_cast<struct_liste_chainee *>(          l_element_courant = reinterpret_cast<struct_liste_chainee *>(
                 s_objet->objet);                  s_objet->objet);
   
Line 288  conversion_cas_vers_rpl(struct_processus Line 395  conversion_cas_vers_rpl(struct_processus
                 }                  }
             }              }
   
             l_element_precedent = l_element_courant;  
             l_element_courant = l_element_courant->suivant;              l_element_courant = l_element_courant->suivant;
         }          }
     }      }
   
       if (empilement(s_etat_processus, &(s_etat_processus->l_base_pile),
               s_objet) == d_erreur)
       {
           return;
       }
   
     return;      return;
 }  }
   #endif
   
   
 /*  /*
Line 310  conversion_cas_vers_rpl(struct_processus Line 423  conversion_cas_vers_rpl(struct_processus
 ================================================================================  ================================================================================
 */  */
   
   #pragma GCC diagnostic push
   #pragma GCC diagnostic ignored "-Wunused-parameter"
 void  void
 interface_cas(struct_processus *s_etat_processus,  interface_cas(struct_processus *s_etat_processus,
         enum t_rplcas_commandes commande)          enum t_rplcas_commandes commande)
 {  {
 #   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_objet            *s_objet_temporaire;
Line 325  interface_cas(struct_processus *s_etat_p Line 440  interface_cas(struct_processus *s_etat_p
     unsigned char           *argument_2;      unsigned char           *argument_2;
     unsigned char           *argument_3;      unsigned char           *argument_3;
     unsigned char           *argument_4;      unsigned char           *argument_4;
     unsigned char           *registre;  
   
     unsigned int            position;      unsigned int            position;
   
       giac::context           *contexte;
   
       if (s_etat_processus->contexte_cas == NULL)
       {
           try
           {
               s_etat_processus->contexte_cas = new giac::context;
           }
           catch(bad_alloc &exception)
           {
               s_etat_processus->erreur_systeme = d_es_allocation_memoire;
               return;
           }
           catch(...)
           {
               s_etat_processus->erreur_execution = d_ex_erreur_interne_rplcas;
               return;
           }
       }
   
       contexte = reinterpret_cast<giac::context *>(
               s_etat_processus->contexte_cas);
   
       giac::angle_radian((test_cfsf(s_etat_processus, 60) == d_vrai) ? 1 : 0,
               contexte);
   
       if ((s_etat_processus->erreur_execution != d_ex) ||
               (s_etat_processus->erreur_systeme != d_es))
       {
           return;
       }
   
     switch(commande)      switch(commande)
     {      {
         case RPLCAS_INTEGRATION:          case RPLCAS_INTEGRATION:
Line 367  interface_cas(struct_processus *s_etat_p Line 513  interface_cas(struct_processus *s_etat_p
   
             try              try
             {              {
                 giac::context   contexte;  
   
                 gen variable(                  gen variable(
                         string(reinterpret_cast<const char *>(argument_1)),                          string(reinterpret_cast<const char *>(argument_1)),
                         &contexte);                          contexte);
                 gen expression(                  gen expression(
                         string(reinterpret_cast<const char *>(argument_2)),                          string(reinterpret_cast<const char *>(argument_2)),
                         &contexte);                          contexte);
   
                 gen resultat = integrate_gen(expression, variable, &contexte);                  gen resultat = integrate_gen(expression, variable,
                           contexte);
                 string chaine = "'" + resultat.print() + "'";                  string chaine = "'" + resultat.print() + "'";
   
                 registre = s_etat_processus->instruction_courante;                  conversion_cas_vers_rpl(s_etat_processus,
                 s_etat_processus->instruction_courante =                          reinterpret_cast<unsigned char *>(const_cast<char *>(
                         reinterpret_cast<unsigned char *>(const_cast<char *>                          chaine.c_str())));
                         (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)              catch(bad_alloc &exception)
             {              {
                 s_etat_processus->erreur_systeme = d_es_allocation_memoire;                  s_etat_processus->erreur_systeme = d_es_allocation_memoire;
             }              }
Line 451  interface_cas(struct_processus *s_etat_p Line 585  interface_cas(struct_processus *s_etat_p
             l_element_courant = reinterpret_cast<struct_liste_chainee *>              l_element_courant = reinterpret_cast<struct_liste_chainee *>
                     (s_objet_argument_1->objet);                      (s_objet_argument_1->objet);
             position = 1;              position = 1;
               argument_1 = NULL;
               argument_3 = NULL;
             argument_4 = NULL;              argument_4 = NULL;
   
             while(l_element_courant != NULL)              while(l_element_courant != NULL)
Line 525  interface_cas(struct_processus *s_etat_p Line 661  interface_cas(struct_processus *s_etat_p
   
             try              try
             {              {
                 giac::context   contexte;  
   
                 int             direction;                  int             direction;
   
                 if (argument_4 == NULL)                  if (argument_4 == NULL)
Line 541  interface_cas(struct_processus *s_etat_p Line 675  interface_cas(struct_processus *s_etat_p
   
                 gen expression(                  gen expression(
                         string(reinterpret_cast<const char *>(argument_2)),                          string(reinterpret_cast<const char *>(argument_2)),
                         &contexte);                          contexte);
                 identificateur variable(                  identificateur variable(
                         string(reinterpret_cast<const char *>(argument_1)));                          string(reinterpret_cast<const char *>(argument_1)));
                 gen valeur(string(reinterpret_cast<const char *>                  gen valeur(string(reinterpret_cast<const char *>
                         (argument_3)), &contexte);                          (argument_3)), contexte);
   
                 gen resultat = limit(expression, variable, valeur, direction,                  gen resultat = limit(expression, variable, valeur, direction,
                         &contexte);                          contexte);
                 string chaine = "'" + resultat.print() + "'";                  string chaine = "'" + resultat.print() + "'";
   
                 registre = s_etat_processus->instruction_courante;                  conversion_cas_vers_rpl(s_etat_processus,
                 s_etat_processus->instruction_courante =                          reinterpret_cast<unsigned char *>(const_cast<char *>(
                         reinterpret_cast<unsigned char *>(const_cast<char *>                          chaine.c_str())));
                         (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)              catch(bad_alloc &exception)
             {              {
                 s_etat_processus->erreur_systeme = d_es_allocation_memoire;                  s_etat_processus->erreur_systeme = d_es_allocation_memoire;
             }              }
Line 586  interface_cas(struct_processus *s_etat_p Line 709  interface_cas(struct_processus *s_etat_p
   
             break;              break;
         }          }
   
           case RPLCAS_SIMPLIFICATION:
           {
               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 ((argument_1 = conversion_rpl_vers_cas(s_etat_processus,
                       &s_objet_argument_1)) == NULL)
               {
                   s_etat_processus->erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               liberation(s_etat_processus, s_objet_argument_1);
   
               try
               {
                   gen expression(
                           string(reinterpret_cast<const char *>(argument_1)),
                           contexte);
   
                   gen resultat = simplify(expression, contexte);
                   string chaine = "'" + resultat.print() + "'";
   
                   conversion_cas_vers_rpl(s_etat_processus,
                           reinterpret_cast<unsigned char *>(const_cast<char *>(
                           chaine.c_str())));
               }
               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);
   
               break;
           }
     }      }
   
     return;      return;
   
 #else  #else
   
     if (s_etat_processus->langue == 'F')      if (s_etat_processus->langue == 'F')
Line 607  interface_cas(struct_processus *s_etat_p Line 774  interface_cas(struct_processus *s_etat_p
   
 #endif  #endif
 }  }
   #pragma GCC diagnostic pop
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.12  
changed lines
  Added in v.1.71

CVSweb interface <joel.bertrand@systella.fr>