[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.6

version 1.2, 2017/06/29 14:54:42 version 1.6, 2018/06/01 13:02:13
Line 8 Line 8
 // Attention : ces fonctions sont à écrire directement en C et non  // Attention : ces fonctions sont à écrire directement en C et non
 // en RPL/C car elles interviennent dans le noyau RPL/2.  // en RPL/C car elles interviennent dans le noyau RPL/2.
   
   /*
   ================================================================================
     Fonction permettant d'extraire un objet d'une suite de caractères
   
     Cette fonction est utilisée par la routine recherche_instruction_suivante()
     du RPL/2.
   ================================================================================
   */
   
 declareTypeExtension(parse)  declareTypeExtension(parse)
     if ((*rptr) == '(')      if ((*rptr) == '(')
     {      {
Line 60  declareTypeExtension(parse) Line 69  declareTypeExtension(parse)
             }              }
         }          }
     }      }
   
       parseError;
 endTypeExtension  endTypeExtension
   
   
   /*
   ================================================================================
     La fonction declareTypeExtension(new) est utilisée par la fonction
     recherche_type() du RPL/2. Elle se charge d'allouer et d'initialiser
     le champ objet de la struct_objet allouée par recherche_type().
   ================================================================================
   */
   
   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");              typeSystemError;
             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 125  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(strcpy(iptr, tmp), free(tmp));
         searchType;  
 printf("<5>\n");  
   
         // Restauration de l'instruction courante          // Restauration de l'instruction courante
         free(iptr);          strcpy(iptr, tmp);
 printf("<6>\n");          free(tmp);
         iptr = tmp;  
           // On doit avoir un vecteur d'entiers au niveau 1 de la pile.
           // Si ce n'est pas le cas, il y a une erreur.
   
 printf("<7>\n");          if ((*(*(*s_etat_processus).l_base_pile).donnee).type != VIN)
         if (((*arg) = malloc(sizeof(integer8))) == NULL)  
         {          {
             typeError;              typeError;
         }          }
   
         (*((integer8 *) arg)) = 10;          nb_elements = (*((struct_vecteur *) (*(*(*s_etat_processus)
 printf("<8>\n");                  .l_base_pile).donnee).objet)).taille;
   
           if (nb_elements > 0)
           {
               if ((vecteur = malloc(nb_elements * sizeof(integer8))) == NULL)
               {
                   typeSystemError;
               }
   
               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)
               {
                   typeSystemError;
               }
           }
           else
           {
               // cas de l'ensemble vide
               if ((vecteur = malloc(0)) == NULL)
               {
                   typeSystemError;
               }
           }
   
           if (((*arg) = malloc(sizeof(set_t))) == NULL)
           {
               typeSystemError;
           }
   
           (**((set_t **) arg)).size = nb_elements;
           (**((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    Fonction de duplication d'un objet.
   
     Cet objet doit être alloué puis copié.
   ================================================================================
   */
   
 declareTypeExtension(dup)  declareTypeExtension(dup)
       integer8        i;
   
       struct_objet    *n_arg;
   
       if ((n_arg = allocation(s_etat_processus, EXT)) == NULL)
       {
           typeSystemError;
       }
   
       if (((*n_arg).objet = malloc(sizeof(set_t))) == NULL)
       {
           typeSystemError;
       }
   
       (*((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;
   
       if (((*((set_t *) ((*n_arg).objet))).values = malloc((*((set_t *)
               ((*n_arg).objet))).size * sizeof(integer8))) == NULL)
       {
           typeSystemError;
       }
   
       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];
       }
   
       (*((struct_objet **) arg)) = n_arg;
       typeSuccess;
 endTypeExtension  endTypeExtension
   
   
   /*
   ================================================================================
     Fonction de libération d'un objet. À l'instar de la fonction new qui n'alloue
     pas la struct_objet, la fonction drop ne doit pas la libérer.
   ================================================================================
   */
   
 declareTypeExtension(drop)  declareTypeExtension(drop)
       free((*((set_t *) (**((struct_objet **) arg)).objet)).values);
       free((**((struct_objet **) arg)).objet);
       typeSuccess;
   endTypeExtension
   
   
   /*
   ================================================================================
     Fonction créant une chaîne de caractère depuis l'objet pour affichage
   ================================================================================
   */
   
   declareTypeExtension(disp)
       int     i;
   
       string  e;
       string  s;
       string  t;
   
       if ((s = malloc(3 * sizeof(unsigned char))) == NULL)
       {
           typeSystemError;
       }
   
       strcpy(s, "([");
   
       for(i = 0; i < (*((set_t *) (*((struct_objet *) (*arg))).objet)).size; i++)
       {
           if ((e = (string) integerFormat(&((*((set_t *)
                   (*((struct_objet *) (*arg))).objet)).values[i]))) == NULL)
           {
               typeSystemError;
           }
   
           t = s;
   
           if ((s = malloc((strlen(t) + strlen(e) + 2) * sizeof(unsigned char)))
                   == NULL)
           {
               typeSystemError;
           }
   
           strcpy(s, t);
           free(t);
           strcat(s, " ");
           strcat(s, e);
           free(e);
       }
   
       t = s;
   
       if ((s = malloc((strlen(t) + 4) * sizeof(unsigned char))) == NULL)
       {
           typeSystemError;
       }
   
       strcpy(s, t);
       free(t);
       strcat(s, " ])");
   
       (*arg) = s;
       typeSuccess;
 endTypeExtension  endTypeExtension
   
   // vim: ts=4
Removed from v.1.2  
changed lines
  Added in v.1.6

CVSweb interface <joel.bertrand@systella.fr>