rpl/modules/sets/types.rplc - diff

Return to types.rplc CVS log

Up to [local] / rpl / modules / sets

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

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

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.3
changed lines
	Added in v.1.4