[BACK]Return to types.rplc CVS log [TXT] [DIR] Up to [local] / rpl / modules / sets

Diff for /rpl/modules/sets/types.rplc between versions 1.2 and 1.3

version 1.2, 2017/06/29 14:54:42 version 1.3, 2017/06/30 13:11:25
Line 62  declareTypeExtension(parse) Line 62  declareTypeExtension(parse)
     }      }
 endTypeExtension  endTypeExtension
   
   static int
   fonction_ordre(const void *a, const void *b)
   {
       if ((*((integer8 *) a)) < (*((integer8 *) b)))
       {
           return(-1);
       }
       if ((*((integer8 *) a)) > (*((integer8 *) b)))
       {
           return(1);
       }
   
       return(0);
   }
   
 declareTypeExtension(new)  declareTypeExtension(new)
     // Si le premier caractère de la chaîne est '(' et que le dernier est ')',      // Si le premier caractère de la chaîne est '(' et que le dernier est ')',
     // on les retire.      // on les retire.
   
     char *tmp;      char            *tmp;
   
       integer8        current_value;
       integer8        i;
       integer8        j;
       integer8        nb_elements;
       integer8        *vecteur;
   
 printf("<1>\n");  
     if (((*iptr) == '(') && ((*(iptr + strlen(iptr) - 1)) == ')'))      if (((*iptr) == '(') && ((*(iptr + strlen(iptr) - 1)) == ')'))
     {      {
         if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char)))          if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char)))
                 == NULL)                  == NULL)
         {          {
 printf("<2>\n");  
             typeError;              typeError;
         }          }
 printf("<3>\n");  
   
         // Sauvegarde de l'instruction courante.          // Sauvegarde de l'instruction courante.
         strcpy(tmp, iptr);          strcpy(tmp, iptr);
Line 87  printf("<3>\n"); Line 105  printf("<3>\n");
         memmove(iptr, iptr + 1, strlen(iptr) - 2);          memmove(iptr, iptr + 1, strlen(iptr) - 2);
         *(iptr + strlen(iptr) - 2) = 0;          *(iptr + strlen(iptr) - 2) = 0;
   
 printf("<4>\n");          searchType(free(iptr), iptr = tmp);
         searchType;  
 printf("<5>\n");  
   
         // Restauration de l'instruction courante          // Restauration de l'instruction courante
         free(iptr);          free(iptr);
 printf("<6>\n");  
         iptr = tmp;          iptr = tmp;
   
 printf("<7>\n");          // On doit avoir un vecteur d'entier au niveau 1 de la pile.
         if (((*arg) = malloc(sizeof(integer8))) == NULL)          // Si ce n'est pas le cas, il y a une erreur.
   
           if ((*(*(*s_etat_processus).l_base_pile).donnee).type != VIN)
           {
               typeError;
           }
   
           nb_elements = (*((struct_vecteur *) (*(*(*s_etat_processus)
                   .l_base_pile).donnee).objet)).taille;
   
           if (nb_elements > 0)
           {
               if ((vecteur = malloc(nb_elements * sizeof(integer8))) == NULL)
               {
                   typeError;
               }
   
               for(i = 0; i < nb_elements; i++)
               {
                   vecteur[i] = ((integer8 *) (*((struct_vecteur *)
                           (*(*(*s_etat_processus)
                           .l_base_pile).donnee).objet)).tableau)[i];
               }
   
               qsort(vecteur, nb_elements, sizeof(integer8), fonction_ordre);
   
               // Élimination des doublons
   
               current_value = vecteur[0];
   
               for(i = 1, j = 1; i < nb_elements; i++)
               {
                   if (vecteur[i] != current_value)
                   {
                       vecteur[j++] = vecteur[i];
                       current_value = vecteur[i];
                   }
               }
   
               nb_elements = j;
   
               if ((vecteur = realloc(vecteur, nb_elements * sizeof(integer8)))
                       == NULL)
               {
                   typeError;
               }
   
               free(vecteur);
           }
           else
           {
               // cas de l'ensemble vide
               if ((vecteur = malloc(0)) == NULL)
               {
                   typeError;
               }
           }
   
           if (((*arg) = malloc(sizeof(set_t))) == NULL)
         {          {
             typeError;              typeError;
         }          }
   
         (*((integer8 *) arg)) = 10;          (**((set_t **) arg)).size = nb_elements;
 printf("<8>\n");          (**((set_t **) arg)).values = vecteur;
   
         instruction_drop(s_etat_processus);          instruction_drop(s_etat_processus);
 printf("<9>\n");  
         typeFound(ISET);          typeFound(ISET);
     }      }
   
 printf("<10>\n");  
     typeError;      typeError;
 endTypeExtension  endTypeExtension
   
 declareTypeExtension(disp)  
     (*arg) = malloc(10);  
     strcpy((*arg), "ici");  
 endTypeExtension  
   
 declareTypeExtension(dup)  declareTypeExtension(dup)
       integer8        i;
   
       struct_objet    *n_arg;
   
       if ((n_arg = allocation(s_etat_processus, EXT)) == NULL)
       {
           typeError;
       }
   
       if (((*n_arg).objet = malloc(sizeof(set_t))) == NULL)
       {
           typeError;
       }
   
       (*((set_t *) ((*n_arg).objet))).size = (*((set_t *) (**((struct_objet **)
               arg)).objet)).size;
       (*n_arg).descripteur_bibliotheque =
               (**((struct_objet **) arg)).descripteur_bibliotheque;
       (*n_arg).extension_type =
               (**((struct_objet **) arg)).extension_type;
   
       for(i = 0; i < (*((set_t *) (**((struct_objet **) arg)).objet)).size; i++)
       {
           (*((set_t *) ((*n_arg).objet))).values[i] =
                   (*((set_t *) (**((struct_objet **) arg)).objet)).values[i];
       }
   
       arg = (void **) &n_arg;
       typeSuccess;
 endTypeExtension  endTypeExtension
   
 declareTypeExtension(drop)  declareTypeExtension(drop)
       // On ne libère surtout pas struct_objet
       free((*((set_t *) (**((struct_objet **) arg)).objet)).values);
       free((**((struct_objet **) arg)).objet);
       typeSuccess;
   endTypeExtension
   
   declareTypeExtension(disp)
       (*arg) = malloc(10);
       strcpy((*arg), "ici");
   // formateur_nombre(s_etat_processus, void* valeur, 'I');
       typeSuccess;
 endTypeExtension  endTypeExtension
   
Removed from v.1.2  
changed lines
  Added in v.1.3

CVSweb interface <joel.bertrand@systella.fr>