![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to types.rplc CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [local] / rpl / modules / sets|
Return to types.rplc CVS log | Up to [local] / rpl / modules / sets |
1.1 bertrand 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:
1.2 bertrand 8: // Attention : ces fonctions sont à écrire directement en C et non
9: // en RPL/C car elles interviennent dans le noyau RPL/2.
10:
1.1 bertrand 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:
1.3 ! bertrand 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:
1.1 bertrand 80: declareTypeExtension(new)
1.2 bertrand 81: // Si le premier caractère de la chaîne est '(' et que le dernier est ')',
82: // on les retire.
83:
1.3 ! bertrand 84: char *tmp;
! 85:
! 86: integer8 current_value;
! 87: integer8 i;
! 88: integer8 j;
! 89: integer8 nb_elements;
! 90: integer8 *vecteur;
1.2 bertrand 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:
1.3 ! bertrand 108: searchType(free(iptr), iptr = tmp);
1.2 bertrand 109:
110: // Restauration de l'instruction courante
111: free(iptr);
112: iptr = tmp;
113:
1.3 ! bertrand 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)
1.2 bertrand 174: {
175: typeError;
176: }
177:
1.3 ! bertrand 178: (**((set_t **) arg)).size = nb_elements;
! 179: (**((set_t **) arg)).values = vecteur;
! 180:
1.2 bertrand 181: instruction_drop(s_etat_processus);
182: typeFound(ISET);
183: }
184:
185: typeError;
1.1 bertrand 186: endTypeExtension
187:
1.3 ! bertrand 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:
1.2 bertrand 227: declareTypeExtension(disp)
228: (*arg) = malloc(10);
229: strcpy((*arg), "ici");
1.3 ! bertrand 230: // formateur_nombre(s_etat_processus, void* valeur, 'I');
! 231: typeSuccess;
1.1 bertrand 232: endTypeExtension
233: