Return to types.rplc CVS log

Up to [local] / rpl / modules / sets

Série de patches pour la gestion des types étendus. Non fonctionnel.

    1: #define TYPE_DECLARATION
    2: #include "src/rplexternals.h"
    3: #include "sets.h"
    4: 
    5: // Les objets de type ensemble sont délimités par ([ ]) et ne contiennent
    6: // que des entiers.
    7: 
    8: // Attention : ces fonctions sont à écrire directement en C et non
    9: // en RPL/C car elles interviennent dans le noyau RPL/2.
   10: 
   11: declareTypeExtension(parse)
   12:     if ((*rptr) == '(')
   13:     {
   14:         rptr++;
   15: 
   16:         if ((*rptr) == '[')
   17:         {
   18:             rptr++;
   19:             while((*rptr) != 0)
   20:             {
   21:                 switch (*rptr)
   22:                 {
   23:                     case '0':
   24:                     case '1':
   25:                     case '2':
   26:                     case '3':
   27:                     case '4':
   28:                     case '5':
   29:                     case '6':
   30:                     case '7':
   31:                     case '8':
   32:                     case '9':
   33:                     case ' ':
   34:                     {
   35:                         break;
   36:                     }
   37: 
   38:                     case ']':
   39:                     {
   40:                         rptr++;
   41: 
   42:                         if ((*rptr) == ')')
   43:                         {
   44:                             rptr++;
   45:                             return(sizeOfParse);
   46:                         }
   47:                         else
   48:                         {
   49:                             parseError;
   50:                         }
   51:                     }
   52: 
   53:                     default:
   54:                     {
   55:                         parseError;
   56:                     }
   57:                 }
   58: 
   59:                 rptr++;
   60:             }
   61:         }
   62:     }
   63: endTypeExtension
   64: 
   65: static int
   66: fonction_ordre(const void *a, const void *b)
   67: {
   68:     if ((*((integer8 *) a)) < (*((integer8 *) b)))
   69:     {
   70:         return(-1);
   71:     }
   72:     if ((*((integer8 *) a)) > (*((integer8 *) b)))
   73:     {
   74:         return(1);
   75:     }
   76: 
   77:     return(0);
   78: }
   79: 
   80: declareTypeExtension(new)
   81:     // Si le premier caractère de la chaîne est '(' et que le dernier est ')',
   82:     // on les retire.
   83: 
   84:     char            *tmp;
   85: 
   86:     integer8        current_value;
   87:     integer8        i;
   88:     integer8        j;
   89:     integer8        nb_elements;
   90:     integer8        *vecteur;
   91: 
   92:     if (((*iptr) == '(') && ((*(iptr + strlen(iptr) - 1)) == ')'))
   93:     {
   94:         if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char)))
   95:                 == NULL)
   96:         {
   97:             typeError;
   98:         }
   99: 
  100:         // Sauvegarde de l'instruction courante.
  101:         strcpy(tmp, iptr);
  102: 
  103:         // Création d'une nouvelle instruction courante amputée de ses premier
  104:         // et dernier caractères.
  105:         memmove(iptr, iptr + 1, strlen(iptr) - 2);
  106:         *(iptr + strlen(iptr) - 2) = 0;
  107: 
  108:         searchType(free(iptr), iptr = tmp);
  109: 
  110:         // Restauration de l'instruction courante
  111:         free(iptr);
  112:         iptr = tmp;
  113: 
  114:         // On doit avoir un vecteur d'entier au niveau 1 de la pile.
  115:         // Si ce n'est pas le cas, il y a une erreur.
  116: 
  117:         if ((*(*(*s_etat_processus).l_base_pile).donnee).type != VIN)
  118:         {
  119:             typeError;
  120:         }
  121: 
  122:         nb_elements = (*((struct_vecteur *) (*(*(*s_etat_processus)
  123:                 .l_base_pile).donnee).objet)).taille;
  124: 
  125:         if (nb_elements > 0)
  126:         {
  127:             if ((vecteur = malloc(nb_elements * sizeof(integer8))) == NULL)
  128:             {
  129:                 typeError;
  130:             }
  131: 
  132:             for(i = 0; i < nb_elements; i++)
  133:             {
  134:                 vecteur[i] = ((integer8 *) (*((struct_vecteur *)
  135:                         (*(*(*s_etat_processus)
  136:                         .l_base_pile).donnee).objet)).tableau)[i];
  137:             }
  138: 
  139:             qsort(vecteur, nb_elements, sizeof(integer8), fonction_ordre);
  140: 
  141:             // Élimination des doublons
  142: 
  143:             current_value = vecteur[0];
  144: 
  145:             for(i = 1, j = 1; i < nb_elements; i++)
  146:             {
  147:                 if (vecteur[i] != current_value)
  148:                 {
  149:                     vecteur[j++] = vecteur[i];
  150:                     current_value = vecteur[i];
  151:                 }
  152:             }
  153: 
  154:             nb_elements = j;
  155: 
  156:             if ((vecteur = realloc(vecteur, nb_elements * sizeof(integer8)))
  157:                     == NULL)
  158:             {
  159:                 typeError;
  160:             }
  161: 
  162:             free(vecteur);
  163:         }
  164:         else
  165:         {
  166:             // cas de l'ensemble vide
  167:             if ((vecteur = malloc(0)) == NULL)
  168:             {
  169:                 typeError;
  170:             }
  171:         }
  172: 
  173:         if (((*arg) = malloc(sizeof(set_t))) == NULL)
  174:         {
  175:             typeError;
  176:         }
  177: 
  178:         (**((set_t **) arg)).size = nb_elements;
  179:         (**((set_t **) arg)).values = vecteur;
  180: 
  181:         instruction_drop(s_etat_processus);
  182:         typeFound(ISET);
  183:     }
  184: 
  185:     typeError;
  186: endTypeExtension
  187: 
  188: declareTypeExtension(dup)
  189:     integer8        i;
  190: 
  191:     struct_objet    *n_arg;
  192: 
  193:     if ((n_arg = allocation(s_etat_processus, EXT)) == NULL)
  194:     {
  195:         typeError;
  196:     }
  197: 
  198:     if (((*n_arg).objet = malloc(sizeof(set_t))) == NULL)
  199:     {
  200:         typeError;
  201:     }
  202: 
  203:     (*((set_t *) ((*n_arg).objet))).size = (*((set_t *) (**((struct_objet **)
  204:             arg)).objet)).size;
  205:     (*n_arg).descripteur_bibliotheque =
  206:             (**((struct_objet **) arg)).descripteur_bibliotheque;
  207:     (*n_arg).extension_type =
  208:             (**((struct_objet **) arg)).extension_type;
  209: 
  210:     for(i = 0; i < (*((set_t *) (**((struct_objet **) arg)).objet)).size; i++)
  211:     {
  212:         (*((set_t *) ((*n_arg).objet))).values[i] =
  213:                 (*((set_t *) (**((struct_objet **) arg)).objet)).values[i];
  214:     }
  215: 
  216:     arg = (void **) &n_arg;
  217:     typeSuccess;
  218: endTypeExtension
  219: 
  220: declareTypeExtension(drop)
  221:     // On ne libère surtout pas struct_objet
  222:     free((*((set_t *) (**((struct_objet **) arg)).objet)).values);
  223:     free((**((struct_objet **) arg)).objet);
  224:     typeSuccess;
  225: endTypeExtension
  226: 
  227: declareTypeExtension(disp)
  228:     (*arg) = malloc(10);
  229:     strcpy((*arg), "ici");
  230: // formateur_nombre(s_etat_processus, void* valeur, 'I');
  231:     typeSuccess;
  232: endTypeExtension
  233: