version 1.3, 2017/06/30 13:11:25
|
version 1.4, 2017/07/02 22:28:20
|
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 62 declareTypeExtension(parse)
|
Line 71 declareTypeExtension(parse)
|
} |
} |
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 |
static int |
fonction_ordre(const void *a, const void *b) |
fonction_ordre(const void *a, const void *b) |
{ |
{ |
Line 94 declareTypeExtension(new)
|
Line 112 declareTypeExtension(new)
|
if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char))) |
if ((tmp = malloc((strlen(iptr) + 1) * sizeof(unsigned char))) |
== NULL) |
== NULL) |
{ |
{ |
typeError; |
typeSystemError; |
} |
} |
|
|
// Sauvegarde de l'instruction courante. |
// Sauvegarde de l'instruction courante. |
Line 105 declareTypeExtension(new)
|
Line 123 declareTypeExtension(new)
|
memmove(iptr, iptr + 1, strlen(iptr) - 2); |
memmove(iptr, iptr + 1, strlen(iptr) - 2); |
*(iptr + strlen(iptr) - 2) = 0; |
*(iptr + strlen(iptr) - 2) = 0; |
|
|
searchType(free(iptr), iptr = tmp); |
searchType(strcpy(iptr, tmp), free(tmp)); |
|
|
// Restauration de l'instruction courante |
// Restauration de l'instruction courante |
free(iptr); |
strcpy(iptr, tmp); |
iptr = tmp; |
free(tmp); |
|
|
// On doit avoir un vecteur d'entier au niveau 1 de la pile. |
// 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. |
// Si ce n'est pas le cas, il y a une erreur. |
|
|
if ((*(*(*s_etat_processus).l_base_pile).donnee).type != VIN) |
if ((*(*(*s_etat_processus).l_base_pile).donnee).type != VIN) |
Line 126 declareTypeExtension(new)
|
Line 144 declareTypeExtension(new)
|
{ |
{ |
if ((vecteur = malloc(nb_elements * sizeof(integer8))) == NULL) |
if ((vecteur = malloc(nb_elements * sizeof(integer8))) == NULL) |
{ |
{ |
typeError; |
typeSystemError; |
} |
} |
|
|
for(i = 0; i < nb_elements; i++) |
for(i = 0; i < nb_elements; i++) |
Line 156 declareTypeExtension(new)
|
Line 174 declareTypeExtension(new)
|
if ((vecteur = realloc(vecteur, nb_elements * sizeof(integer8))) |
if ((vecteur = realloc(vecteur, nb_elements * sizeof(integer8))) |
== NULL) |
== NULL) |
{ |
{ |
typeError; |
typeSystemError; |
} |
} |
|
|
free(vecteur); |
|
} |
} |
else |
else |
{ |
{ |
// cas de l'ensemble vide |
// cas de l'ensemble vide |
if ((vecteur = malloc(0)) == NULL) |
if ((vecteur = malloc(0)) == NULL) |
{ |
{ |
typeError; |
typeSystemError; |
} |
} |
} |
} |
|
|
if (((*arg) = malloc(sizeof(set_t))) == NULL) |
if (((*arg) = malloc(sizeof(set_t))) == NULL) |
{ |
{ |
typeError; |
typeSystemError; |
} |
} |
|
|
(**((set_t **) arg)).size = nb_elements; |
(**((set_t **) arg)).size = nb_elements; |
Line 185 declareTypeExtension(new)
|
Line 201 declareTypeExtension(new)
|
typeError; |
typeError; |
endTypeExtension |
endTypeExtension |
|
|
|
|
|
/* |
|
================================================================================ |
|
Fonction de duplication d'un objet. |
|
|
|
Cet objet doit être alloué puis copié. |
|
================================================================================ |
|
*/ |
|
|
declareTypeExtension(dup) |
declareTypeExtension(dup) |
integer8 i; |
integer8 i; |
|
|
Line 192 declareTypeExtension(dup)
|
Line 217 declareTypeExtension(dup)
|
|
|
if ((n_arg = allocation(s_etat_processus, EXT)) == NULL) |
if ((n_arg = allocation(s_etat_processus, EXT)) == NULL) |
{ |
{ |
typeError; |
typeSystemError; |
} |
} |
|
|
if (((*n_arg).objet = malloc(sizeof(set_t))) == NULL) |
if (((*n_arg).objet = malloc(sizeof(set_t))) == NULL) |
{ |
{ |
typeError; |
typeSystemError; |
} |
} |
|
|
(*((set_t *) ((*n_arg).objet))).size = (*((set_t *) (**((struct_objet **) |
(*((set_t *) ((*n_arg).objet))).size = (*((set_t *) (**((struct_objet **) |
Line 217 declareTypeExtension(dup)
|
Line 242 declareTypeExtension(dup)
|
typeSuccess; |
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) |
// On ne libère surtout pas struct_objet |
|
free((*((set_t *) (**((struct_objet **) arg)).objet)).values); |
free((*((set_t *) (**((struct_objet **) arg)).objet)).values); |
free((**((struct_objet **) arg)).objet); |
free((**((struct_objet **) arg)).objet); |
typeSuccess; |
typeSuccess; |
endTypeExtension |
endTypeExtension |
|
|
|
|
|
/* |
|
================================================================================ |
|
Fonction créant une chaîne de caractère depuis l'objet pour affichage |
|
================================================================================ |
|
*/ |
|
|
declareTypeExtension(disp) |
declareTypeExtension(disp) |
(*arg) = malloc(10); |
int i; |
strcpy((*arg), "ici"); |
|
// formateur_nombre(s_etat_processus, void* valeur, '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; |
typeSuccess; |
endTypeExtension |
endTypeExtension |
|
|
|
// vim: ts=4 |