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

Diff for /rpl/src/instructions_r6.c between versions 1.43 and 1.49

version 1.43, 2012/10/01 11:05:06 version 1.49, 2013/03/21 12:07:38
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.11    RPL/2 (R) version 4.1.13
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 492  instruction_row_fleche(struct_processus Line 492  instruction_row_fleche(struct_processus
     struct_objet                *s_objet;      struct_objet                *s_objet;
     struct_objet                *s_objet_elementaire;      struct_objet                *s_objet_elementaire;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 565  instruction_row_fleche(struct_processus Line 565  instruction_row_fleche(struct_processus
             }              }
   
             if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)              if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
                     .objet)).tableau)[0] = malloc((*((struct_matrice *)                      .objet)).tableau)[0] = malloc(((size_t)
                     (*s_objet_elementaire).objet)).nombre_colonnes *                      (*((struct_matrice *) (*s_objet_elementaire).objet))
                     sizeof(integer8))) == NULL)                      .nombre_colonnes) * sizeof(integer8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
                         d_es_allocation_memoire;                          d_es_allocation_memoire;
Line 617  instruction_row_fleche(struct_processus Line 617  instruction_row_fleche(struct_processus
             }              }
   
             if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire)              if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
                     .objet)).tableau)[0] = malloc((*((struct_matrice *)                      .objet)).tableau)[0] = malloc(((size_t)
                     (*s_objet_elementaire).objet)).nombre_colonnes *                      (*((struct_matrice *) (*s_objet_elementaire).objet))
                     sizeof(real8))) == NULL)                      .nombre_colonnes) * sizeof(real8))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
                         d_es_allocation_memoire;                          d_es_allocation_memoire;
Line 669  instruction_row_fleche(struct_processus Line 669  instruction_row_fleche(struct_processus
             }              }
   
             if ((((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)              if ((((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
                     .objet)).tableau)[0] = malloc((*((struct_matrice *)                      .objet)).tableau)[0] = malloc(((size_t)
                     (*s_objet_elementaire).objet)).nombre_colonnes *                      (*((struct_matrice *) (*s_objet_elementaire).objet))
                     sizeof(complex16))) == NULL)                      .nombre_colonnes) * sizeof(complex16))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
                         d_es_allocation_memoire;                          d_es_allocation_memoire;
Line 1205  instruction_rdgn(struct_processus *s_eta Line 1205  instruction_rdgn(struct_processus *s_eta
     long                        dernier;      long                        dernier;
     long                        i;      long                        i;
     long                        j;      long                        j;
       long                        nombre_types;
     long                        premier;      long                        premier;
   
     struct_objet                *s_objet_argument;      struct_objet                *s_objet_argument;
Line 1214  instruction_rdgn(struct_processus *s_eta Line 1215  instruction_rdgn(struct_processus *s_eta
     unsigned char               *requete;      unsigned char               *requete;
     unsigned char               **types_generateurs;      unsigned char               **types_generateurs;
   
     unsigned long               nombre_types;  
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     types = gsl_rng_types_setup();      types = gsl_rng_types_setup();
Line 1250  instruction_rdgn(struct_processus *s_eta Line 1249  instruction_rdgn(struct_processus *s_eta
         for(nombre_types = 0, type_courant = types;          for(nombre_types = 0, type_courant = types;
                 (*type_courant) != NULL; type_courant++, nombre_types++);                  (*type_courant) != NULL; type_courant++, nombre_types++);
   
         if ((types_generateurs = malloc(nombre_types * sizeof(unsigned char *)))          if ((types_generateurs = malloc(((size_t) nombre_types) *
                 == NULL)                  sizeof(unsigned char *))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1316  instruction_rdgn(struct_processus *s_eta Line 1315  instruction_rdgn(struct_processus *s_eta
             premier = j;              premier = j;
         }          }
   
         for(i = 0; i < (long) nombre_types; i++)          for(i = 0; i < nombre_types; i++)
         {          {
             printf("  - %s\n", types_generateurs[i]);              printf("  - %s\n", types_generateurs[i]);
             free(types_generateurs[i]);              free(types_generateurs[i]);
Line 1714  instruction_recode(struct_processus *s_e Line 1713  instruction_recode(struct_processus *s_e
 void  void
 instruction_repl(struct_processus *s_etat_processus)  instruction_repl(struct_processus *s_etat_processus)
 {  {
       integer8                        difference;
       integer8                        difference_ecriture;
       integer8                        difference_lecture;
       integer8                        nombre_occurrences;
     integer8                        position;      integer8                        position;
   
     long                            difference;  
     long                            difference_ecriture;  
     long                            difference_lecture;  
     long                            nombre_occurrences;  
   
     struct_liste_chainee            *l_element_a_supprimer;      struct_liste_chainee            *l_element_a_supprimer;
     struct_liste_chainee            *l_element_courant;      struct_liste_chainee            *l_element_courant;
     struct_liste_chainee            *l_element_courant_2;      struct_liste_chainee            *l_element_courant_2;
Line 1839  instruction_repl(struct_processus *s_eta Line 1837  instruction_repl(struct_processus *s_eta
         // Différence est positive si la nouvelle chaîne est plus longue          // Différence est positive si la nouvelle chaîne est plus longue
         // que la chaîne originelle.          // que la chaîne originelle.
   
         difference = strlen((unsigned char *) (*s_objet_argument_1).objet)          difference = ((integer8) strlen((unsigned char *) (*s_objet_argument_1)
                 - strlen((unsigned char *) (*s_objet_argument_2).objet);                  .objet)) - ((integer8) strlen((unsigned char *)
                   (*s_objet_argument_2).objet));
   
         if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)          if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
         {          {
Line 1849  instruction_repl(struct_processus *s_eta Line 1848  instruction_repl(struct_processus *s_eta
         }          }
   
         if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *)          if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *)
                 (*s_objet_argument_3).objet) + (nombre_occurrences *                  (*s_objet_argument_3).objet) + ((size_t) (nombre_occurrences *
                 difference) + 1) * sizeof(unsigned char))) == NULL)                  difference)) + 1) * sizeof(unsigned char))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 1858  instruction_repl(struct_processus *s_eta Line 1857  instruction_repl(struct_processus *s_eta
   
         pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;          pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
         pointeur_ecriture = (unsigned char *) (*s_objet_resultat).objet;          pointeur_ecriture = (unsigned char *) (*s_objet_resultat).objet;
         difference_lecture = strlen((unsigned char *)          difference_lecture = (integer8) strlen((unsigned char *)
                 (*s_objet_argument_2).objet);                  (*s_objet_argument_2).objet);
         difference_ecriture = strlen((unsigned char *)          difference_ecriture = (integer8) strlen((unsigned char *)
                 (*s_objet_argument_1).objet);                  (*s_objet_argument_1).objet);
   
         for(;;)          for(;;)
Line 1878  instruction_repl(struct_processus *s_eta Line 1877  instruction_repl(struct_processus *s_eta
             }              }
   
             strncpy(ancien_pointeur_ecriture, ancien_pointeur_lecture,              strncpy(ancien_pointeur_ecriture, ancien_pointeur_lecture,
                     pointeur_lecture - ancien_pointeur_lecture);                      (size_t) (pointeur_lecture - ancien_pointeur_lecture));
             strcpy(ancien_pointeur_ecriture +              strcpy(ancien_pointeur_ecriture +
                     (pointeur_lecture - ancien_pointeur_lecture),                      (pointeur_lecture - ancien_pointeur_lecture),
                     (unsigned char *) (*s_objet_argument_1).objet);                      (unsigned char *) (*s_objet_argument_1).objet);
Removed from v.1.43  
changed lines
  Added in v.1.49

CVSweb interface <joel.bertrand@systella.fr>