Diff for /rpl/src/instructions_c3.c between versions 1.29 and 1.58

version 1.29, 2011/07/25 07:44:55 version 1.58, 2015/02/19 11:01:22
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.2    RPL/2 (R) version 4.1.21
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 143  instruction_cnrm(struct_processus *s_eta Line 143  instruction_cnrm(struct_processus *s_eta
     struct_objet                *s_objet_argument;      struct_objet                *s_objet_argument;
     struct_objet                *s_objet_resultat;      struct_objet                *s_objet_resultat;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
   
     void                        *accumulateur;      void                        *accumulateur;
   
Line 206  instruction_cnrm(struct_processus *s_eta Line 206  instruction_cnrm(struct_processus *s_eta
         for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet)).taille;          for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
                 i++)                  i++)
         {          {
               if (((integer8 *) (*((struct_vecteur *) (*s_objet_argument).objet))
                       .tableau)[i] == INT64_MIN)
               {
                   depassement = d_vrai;
                   break;
               }
   
             entier_courant = abs(((integer8 *) (*((struct_vecteur *)              entier_courant = abs(((integer8 *) (*((struct_vecteur *)
                     (*s_objet_argument).objet)).tableau)[i]);                      (*s_objet_argument).objet)).tableau)[i]);
   
Line 237  instruction_cnrm(struct_processus *s_eta Line 244  instruction_cnrm(struct_processus *s_eta
             for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))              for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
                     .taille; i++)                      .taille; i++)
             {              {
                 cumul_reel += (real8) abs(((integer8 *) (*((struct_vecteur *)                  cumul_reel += abs((real8) ((integer8 *) (*((struct_vecteur *)
                         (*s_objet_argument).objet)).tableau)[i]);                          (*s_objet_argument).objet)).tableau)[i]);
             }              }
   
Line 260  instruction_cnrm(struct_processus *s_eta Line 267  instruction_cnrm(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((accumulateur = malloc((*((struct_vecteur *)          if ((accumulateur = malloc(((size_t) (*((struct_vecteur *)
                 (*s_objet_argument).objet)).taille * sizeof(real8))) == NULL)                  (*s_objet_argument).objet)).taille) * sizeof(real8))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 296  instruction_cnrm(struct_processus *s_eta Line 303  instruction_cnrm(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((accumulateur = malloc((*((struct_vecteur *)          if ((accumulateur = malloc(((size_t) (*((struct_vecteur *)
                 (*s_objet_argument).objet)).taille * sizeof(real8))) == NULL)                  (*s_objet_argument).objet)).taille) * sizeof(real8))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 345  instruction_cnrm(struct_processus *s_eta Line 352  instruction_cnrm(struct_processus *s_eta
         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++)
         {          {
               if (((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet))
                       .tableau)[i][0] == INT64_MIN)
               {
                   depassement = d_vrai;
                   break;
               }
   
             entier_courant = abs(((integer8 **)              entier_courant = abs(((integer8 **)
                     (*((struct_matrice *) (*s_objet_argument).objet))                      (*((struct_matrice *) (*s_objet_argument).objet))
                     .tableau)[i][0]);                      .tableau)[i][0]);
Line 371  instruction_cnrm(struct_processus *s_eta Line 385  instruction_cnrm(struct_processus *s_eta
                 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++)
                 {                  {
                       if ((((integer8 **) (*((struct_matrice *)
                               (*s_objet_argument).objet)).tableau)[i][j])
                               == INT64_MIN)
                       {
                           depassement = d_vrai;
                           break;
                       }
   
                     entier_courant = abs(((integer8 **) (*((struct_matrice *)                      entier_courant = abs(((integer8 **) (*((struct_matrice *)
                             (*s_objet_argument).objet)).tableau)[i][j]);                              (*s_objet_argument).objet)).tableau)[i][j]);
   
Line 411  instruction_cnrm(struct_processus *s_eta Line 433  instruction_cnrm(struct_processus *s_eta
                 return;                  return;
             }              }
   
             if ((accumulateur = malloc((*((struct_matrice *)              if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
                     (*s_objet_argument).objet)).nombre_lignes * sizeof(real8)))                      (*s_objet_argument).objet)).nombre_lignes) * sizeof(real8)))
                     == NULL)                      == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 427  instruction_cnrm(struct_processus *s_eta Line 449  instruction_cnrm(struct_processus *s_eta
                 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++)
                 {                  {
                     ((real8 *) accumulateur)[i] = fabs((real8) ((integer8 **)                      ((real8 *) accumulateur)[i] = abs((real8) ((integer8 **)
                             (*((struct_matrice *)                              (*((struct_matrice *)
                             (*s_objet_argument).objet)).tableau)[i][j]);                              (*s_objet_argument).objet)).tableau)[i][j]);
                 }                  }
Line 461  instruction_cnrm(struct_processus *s_eta Line 483  instruction_cnrm(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((accumulateur = malloc((*((struct_matrice *)          if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
                 (*s_objet_argument).objet)).nombre_lignes * sizeof(real8)))                  (*s_objet_argument).objet)).nombre_lignes) * sizeof(real8)))
                 == NULL)                  == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 477  instruction_cnrm(struct_processus *s_eta Line 499  instruction_cnrm(struct_processus *s_eta
             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++)
             {              {
                 ((real8 *) accumulateur)[i] = fabs(((real8 **)                  ((real8 *) accumulateur)[i] = abs(((real8 **)
                         (*((struct_matrice *)                          (*((struct_matrice *)
                         (*s_objet_argument).objet)).tableau)[i][j]);                          (*s_objet_argument).objet)).tableau)[i][j]);
             }              }
Line 509  instruction_cnrm(struct_processus *s_eta Line 531  instruction_cnrm(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((accumulateur = malloc((*((struct_matrice *)          if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
                 (*s_objet_argument).objet)).nombre_lignes * sizeof(real8)))                  (*s_objet_argument).objet)).nombre_lignes) * sizeof(real8)))
                 == NULL)                  == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 660  instruction_chr(struct_processus *s_etat Line 682  instruction_chr(struct_processus *s_etat
                 return;                  return;
             }              }
   
             if (((*s_objet_resultat).objet = malloc(2 * sizeof(unsigned char)))              if ((*((integer8 *) (*s_objet_argument).objet)) == '\\')
                     == NULL)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  if (((*s_objet_resultat).objet = malloc(3 *
                 return;                          sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   ((unsigned char *) (*s_objet_resultat).objet)[0] = '\\';
                   ((unsigned char *) (*s_objet_resultat).objet)[1] = '\\';
                   ((unsigned char *) (*s_objet_resultat).objet)[2] =
                           d_code_fin_chaine;
             }              }
               else if ((*((integer8 *) (*s_objet_argument).objet)) == '"')
               {
                   if (((*s_objet_resultat).objet = malloc(3 *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
             ((unsigned char *) (*s_objet_resultat).objet)[0] = (*((integer8 *)                  ((unsigned char *) (*s_objet_resultat).objet)[0] = '\\';
                     (*s_objet_argument).objet));                  ((unsigned char *) (*s_objet_resultat).objet)[1] = '"';
             ((unsigned char *) (*s_objet_resultat).objet)[1] =                  ((unsigned char *) (*s_objet_resultat).objet)[2] =
                     d_code_fin_chaine;                          d_code_fin_chaine;
               }
               else
               {
                   if (((*s_objet_resultat).objet = malloc(2 *
                           sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   ((unsigned char *) (*s_objet_resultat).objet)[0] =
                           (unsigned char) (*((integer8 *)
                           (*s_objet_argument).objet));
                   ((unsigned char *) (*s_objet_resultat).objet)[1] =
                           d_code_fin_chaine;
               }
         }          }
         else          else
         {          {
             liberation(s_etat_processus, s_objet_argument);              if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
             (*s_etat_processus).erreur_execution = d_ex_argument_invalide;              if (((*s_objet_resultat).objet = malloc(5 * sizeof(unsigned char)))
             return;                      == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               sprintf((unsigned char *) (*s_objet_resultat).objet, "\\x%02X",
                       (unsigned char) (*((integer8 *)
                       (*s_objet_argument).objet)));
         }          }
     }      }
   

Removed from v.1.29  
changed lines
  Added in v.1.58


CVSweb interface <joel.bertrand@systella.fr>