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

Diff for /rpl/src/instructions_n1.c between versions 1.46 and 1.67

version 1.46, 2013/03/24 23:11:30 version 1.67, 2018/12/24 15:56:01
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.30
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2018 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 112  instruction_neg(struct_processus *s_etat Line 112  instruction_neg(struct_processus *s_etat
   
     if ((*s_objet_argument).type == INT)      if ((*s_objet_argument).type == INT)
     {      {
         if ((s_objet_resultat = copie_objet(s_etat_processus,          if ((*((integer8 *) (*s_objet_argument).objet)) != INT64_MIN)
                 s_objet_argument, 'Q')) == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              if ((s_objet_resultat = copie_objet(s_etat_processus,
             return;                      s_objet_argument, 'Q')) == NULL)
         }              {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
         /*              /*
          * Permet d'éviter les résultats du type -0. Valable pour tous               * Permet d'éviter les résultats du type -0. Valable pour tous
          * les types...               * les types...
          */               */
   
         if ((*((integer8 *) (*s_objet_argument).objet)) != 0)              if ((*((integer8 *) (*s_objet_argument).objet)) != 0)
               {
                   (*((integer8 *) (*s_objet_resultat).objet)) =
                           -(*((integer8 *) (*s_objet_argument).objet));
               }
           }
           else
         {          {
             (*((integer8 *) (*s_objet_resultat).objet)) =              if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
                     -(*((integer8 *) (*s_objet_argument).objet));              {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*((real8 *) (*s_objet_resultat).objet)) =
                       -((real8) (*((integer8 *) (*s_objet_argument).objet)));
   
         }          }
     }      }
   
Line 194  instruction_neg(struct_processus *s_etat Line 209  instruction_neg(struct_processus *s_etat
   
     else if ((*s_objet_argument).type == VIN)      else if ((*s_objet_argument).type == VIN)
     {      {
         if ((s_objet_resultat = copie_objet(s_etat_processus,          drapeau = d_faux;
                 s_objet_argument, 'Q')) == NULL)  
           for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
                   .taille; i++)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              if (((integer8 *) (*((struct_vecteur *)
             return;                      (*s_objet_argument).objet)).tableau)[i] == INT64_MIN)
               {
                   drapeau = d_vrai;
                   break;
               }
         }          }
   
         for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))          if (drapeau == d_vrai)
                 .taille; i++)  
         {          {
             if (((integer8 *) (*(((struct_vecteur *)              if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
                     (*s_objet_argument).objet))).tableau)[i] != 0)  
             {              {
                 ((integer8 *) (*(((struct_vecteur *) (*s_objet_resultat)                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                         .objet))).tableau)[i] = -((integer8 *)                  return;
                         (*(((struct_vecteur *)              }
                         (*s_objet_argument).objet))).tableau)[i];  
               if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
                       malloc(((size_t) (*((struct_vecteur *) (*s_objet_argument)
                       .objet)).taille) * sizeof(real8))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
                       .taille; i++)
               {
                   if (((real8 *) (*(((struct_vecteur *)
                           (*s_objet_argument).objet))).tableau)[i] != 0)
                   {
                       ((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
                               .objet)).tableau)[i] = -((real8) ((integer8 *)
                               (*((struct_vecteur *)
                               (*s_objet_argument).objet)).tableau)[i]);
                   }
                   else
                   {
                       ((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
                               .objet)).tableau)[i] = 0;
                   }
               }
           }
           else
           {
               if ((s_objet_resultat = copie_objet(s_etat_processus,
                       s_objet_argument, 'Q')) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
                       .taille; i++)
               {
                   if (((integer8 *) (*(((struct_vecteur *)
                           (*s_objet_argument).objet))).tableau)[i] != 0)
                   {
                       ((integer8 *) (*(((struct_vecteur *) (*s_objet_resultat)
                               .objet))).tableau)[i] = -((integer8 *)
                               (*(((struct_vecteur *)
                               (*s_objet_argument).objet))).tableau)[i];
                   }
             }              }
         }          }
     }      }
Line 293  instruction_neg(struct_processus *s_etat Line 358  instruction_neg(struct_processus *s_etat
   
     else if ((*s_objet_argument).type == MIN)      else if ((*s_objet_argument).type == MIN)
     {      {
         if ((s_objet_resultat = copie_objet(s_etat_processus,          drapeau = d_faux;
                 s_objet_argument, 'Q')) == NULL)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return;  
         }  
   
         for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet)))          for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
                 .nombre_lignes; i++)                  .nombre_lignes; i++)
         {          {
             for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))              for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
                     .nombre_colonnes; j++)                      .nombre_colonnes; j++)
             {              {
                 if (((integer8 **) (*(((struct_matrice *) (*s_objet_argument)                  if (((integer8 **) (*((struct_vecteur *)
                         .objet))).tableau)[i][j] != 0)                          (*s_objet_argument).objet)).tableau)[i][j] == INT64_MIN)
                   {
                       drapeau = d_vrai;
                       break;
                   }
               }
   
               if (drapeau == d_vrai)
               {
                   break;
               }
           }
   
           if (drapeau == d_vrai)
           {
               if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                       malloc(((size_t) (*((struct_matrice *) (*s_objet_argument)
                       .objet)).nombre_lignes) * sizeof(real8 *))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
                       .nombre_lignes; i++)
               {
                   if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
                           .objet)).tableau)[i] = malloc(((size_t)
                           ((*((struct_matrice *) (*s_objet_argument).objet))
                           .nombre_colonnes)) * sizeof(real8))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   for(j = 0; j < (*((struct_matrice *) (*s_objet_argument)
                           .objet)).nombre_colonnes; j++)
                   {
                       if (((integer8 **) (*((struct_matrice *)
                               (*s_objet_argument).objet)).tableau)[i][j] != 0)
                       {
                           ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
                                   .objet)).tableau)[i][j] = -((real8)
                                   ((integer8 **) (*(((struct_matrice *)
                                   (*s_objet_argument).objet))).tableau)[i][j]);
                       }
                       else
                       {
                           ((real8 **) (*((struct_matrice *) (*s_objet_resultat)
                                   .objet)).tableau)[i][j] = 0;
                       }
                   }
               }
           }
           else
           {
               if ((s_objet_resultat = copie_objet(s_etat_processus,
                       s_objet_argument, 'Q')) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
                       .nombre_lignes; i++)
               {
                   for(j = 0; j < (*((struct_matrice *) (*s_objet_argument)
                           .objet)).nombre_colonnes; j++)
                 {                  {
                     ((integer8 **) (*(((struct_matrice *) (*s_objet_resultat)                      if (((integer8 **) (*((struct_matrice *)
                             .objet))).tableau)[i][j] = -((integer8 **)                              (*s_objet_argument).objet)).tableau)[i][j] != 0)
                             (*(((struct_matrice *)                      {
                             (*s_objet_argument).objet))).tableau)[i][j];                          ((integer8 **) (*((struct_matrice *)
                                   (*s_objet_resultat).objet)).tableau)[i][j] =
                                   -((integer8 **) (*((struct_matrice *)
                                   (*s_objet_argument).objet)).tableau)[i][j];
                       }
                 }                  }
             }              }
         }          }
Removed from v.1.46  
changed lines
  Added in v.1.67

CVSweb interface <joel.bertrand@systella.fr>