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

Diff for /rpl/src/instructions_i3.c between versions 1.19 and 1.70

version 1.19, 2011/04/21 16:00:57 version 1.70, 2020/01/10 11:15:46
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.0    RPL/2 (R) version 4.1.32
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2020 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 96  instruction_inquire(struct_processus *s_ Line 96  instruction_inquire(struct_processus *s_
         printf("    NAME           : %s\n", d_CHN);          printf("    NAME           : %s\n", d_CHN);
         printf("    FORMATTED      : %s (true/false)\n", d_INT);          printf("    FORMATTED      : %s (true/false)\n", d_INT);
         printf("    KEY FIELD      : %s\n", d_INT);          printf("    KEY FIELD      : %s\n", d_INT);
           printf("    FORMAT         : %s\n", d_LST);
         printf("    PROTECTION     : %s (WRITEONLY/READONLY/READWRITE)\n\n",          printf("    PROTECTION     : %s (WRITEONLY/READONLY/READWRITE)\n\n",
                 d_CHN);                  d_CHN);
   
Line 108  instruction_inquire(struct_processus *s_ Line 109  instruction_inquire(struct_processus *s_
             printf("  Queries by name:\n\n");              printf("  Queries by name:\n\n");
         }          }
   
         printf("    FORMAT         : %s\n", d_LST);  
         printf("    EXISTENCE      : %s (true/false)\n", d_INT);          printf("    EXISTENCE      : %s (true/false)\n", d_INT);
         printf("    LOCK           : %s (NONE/READ/WRITE)\n", d_CHN);          printf("    LOCK           : %s (NONE/READ/WRITE)\n", d_CHN);
   
Line 153  instruction_inquire(struct_processus *s_ Line 153  instruction_inquire(struct_processus *s_
         return;          return;
     }      }
   
     if ((requete = conversion_majuscule((unsigned char *)      if ((requete = conversion_majuscule(s_etat_processus, (unsigned char *)
             (*s_objet_argument_1).objet)) == NULL)              (*s_objet_argument_1).objet)) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 188  instruction_inquire(struct_processus *s_ Line 188  instruction_inquire(struct_processus *s_
                 return;                  return;
             }              }
   
             /*  
              * La fin du fichier renvoyée ne correspond pas à la fin physique  
              * du fichier mais à un défaut d'enregistrement.  
              */  
   
             if ((dfichier = descripteur_fichier(s_etat_processus,              if ((dfichier = descripteur_fichier(s_etat_processus,
                     (struct_fichier *) (*s_objet_argument_2).objet)) == NULL)                      (struct_fichier *) (*s_objet_argument_2).objet)) ==
                       NULL)
             {              {
                 return;                  return;
             }              }
Line 206  instruction_inquire(struct_processus *s_ Line 202  instruction_inquire(struct_processus *s_
   
                 free(requete);                  free(requete);
   
                 (*s_etat_processus).erreur_execution = d_ex_erreur_type_fichier;                  (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_fichier;
                 return;                  return;
             }              }
   
             if ((position_courante = ftell((*dfichier).descripteur_c)) == -1)              if ((*((struct_fichier *) (*s_objet_argument_2).objet)).binaire
                       != 'F')
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                  /*
                 return;                   * La fin du fichier renvoyée ne correspond pas à la fin
             }                   * physique du fichier mais à un défaut d'enregistrement.
                    */
   
             fin_fichier = d_vrai;                  if ((position_courante = ftell((*dfichier).descripteur_c))
                           == -1)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
             while(feof((*dfichier).descripteur_c) == 0)                  fin_fichier = d_vrai;
             {  
                 if (fread(&caractere, sizeof(unsigned char), (size_t) 1,                  while(feof((*dfichier).descripteur_c) == 0)
                         (*dfichier).descripteur_c) > 0)  
                 {                  {
                     if (caractere == '{')                      if (fread(&caractere, sizeof(unsigned char), (size_t) 1,
                               (*dfichier).descripteur_c) > 0)
                     {                      {
                         fin_fichier = d_faux;                          if (caractere == '{')
                         break;                          {
                               fin_fichier = d_faux;
                               break;
                           }
                     }                      }
                 }                  }
             }  
   
             if (fseek((*dfichier).descripteur_c, position_courante, SEEK_SET)                  if (fseek((*dfichier).descripteur_c, position_courante,
                     != 0)                          SEEK_SET) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
               }
               else
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                  // Fichier de type FLOW
                 return;                  if (feof((*dfichier).descripteur_c) == 0)
                   {
                       fin_fichier = d_faux;
                   }
                   else
                   {
                       fin_fichier = d_vrai;
                   }
             }              }
   
             if (fin_fichier == d_faux)              if (fin_fichier == d_faux)
Line 770  instruction_idft(struct_processus *s_eta Line 789  instruction_idft(struct_processus *s_eta
   
     logical1                    presence_longueur_dft;      logical1                    presence_longueur_dft;
   
     long                        longueur_dft_signee;      integer8                    longueur_dft_signee;
   
     struct_complexe16           *matrice_f77;      struct_complexe16           *matrice_f77;
   
Line 778  instruction_idft(struct_processus *s_eta Line 797  instruction_idft(struct_processus *s_eta
     struct_objet                *s_objet_longueur_dft;      struct_objet                *s_objet_longueur_dft;
     struct_objet                *s_objet_resultat;      struct_objet                *s_objet_resultat;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
     unsigned long               k;      integer8                    k;
     unsigned long               longueur_dft;      integer8                    longueur_dft;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 899  instruction_idft(struct_processus *s_eta Line 918  instruction_idft(struct_processus *s_eta
                     (*s_objet_argument).objet)).taille;                      (*s_objet_argument).objet)).taille;
         }          }
   
         if ((matrice_f77 = malloc(longueur_dft *          if ((matrice_f77 = malloc(((size_t) longueur_dft) *
                 sizeof(struct_complexe16))) == NULL)                  sizeof(struct_complexe16))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 949  instruction_idft(struct_processus *s_eta Line 968  instruction_idft(struct_processus *s_eta
         }          }
   
         nombre_lignes = 1;          nombre_lignes = 1;
         nombre_colonnes = longueur_dft;          nombre_colonnes = (integer4) longueur_dft;
         inverse = -1;          inverse = -1;
   
         dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);          dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
Line 989  instruction_idft(struct_processus *s_eta Line 1008  instruction_idft(struct_processus *s_eta
                     (*s_objet_argument).objet)).nombre_colonnes;                      (*s_objet_argument).objet)).nombre_colonnes;
         }          }
   
         if ((matrice_f77 = malloc(longueur_dft *          if ((matrice_f77 = malloc(((size_t) longueur_dft) * ((size_t)
                 (*((struct_matrice *) (*s_objet_argument).objet))                  (*((struct_matrice *) (*s_objet_argument).objet))
                 .nombre_lignes * sizeof(struct_complexe16))) == NULL)                  .nombre_lignes) * sizeof(struct_complexe16))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1067  instruction_idft(struct_processus *s_eta Line 1086  instruction_idft(struct_processus *s_eta
             }              }
         }          }
   
         nombre_lignes = (*((struct_matrice *) (*s_objet_argument).objet))          nombre_lignes = (integer4) (*((struct_matrice *) (*s_objet_argument)
                 .nombre_lignes;                  .objet)).nombre_lignes;
         nombre_colonnes = longueur_dft;          nombre_colonnes = (integer4) longueur_dft;
         inverse = -1;          inverse = -1;
   
         dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);          dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
Line 1096  instruction_idft(struct_processus *s_eta Line 1115  instruction_idft(struct_processus *s_eta
                 longueur_dft;                  longueur_dft;
   
         if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =          if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
                 malloc((*((struct_matrice *) (*s_objet_resultat).objet))                  malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
                 .nombre_lignes * sizeof(struct_complexe16 *))) == NULL)                  .objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1108  instruction_idft(struct_processus *s_eta Line 1127  instruction_idft(struct_processus *s_eta
         {          {
             if ((((struct_complexe16 **) (*((struct_matrice *)              if ((((struct_complexe16 **) (*((struct_matrice *)
                     (*s_objet_resultat).objet)).tableau)[i] =                      (*s_objet_resultat).objet)).tableau)[i] =
                     malloc((*((struct_matrice *)                      malloc(((size_t) (*((struct_matrice *)
                     (*s_objet_resultat).objet)).nombre_colonnes *                      (*s_objet_resultat).objet)).nombre_colonnes) *
                     sizeof(struct_complexe16))) == NULL)                      sizeof(struct_complexe16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Removed from v.1.19  
changed lines
  Added in v.1.70

CVSweb interface <joel.bertrand@systella.fr>