Bonjour,
j'ai un probleme d'ecrasement de pointeur , j'ai une fonction qui fais une copie d'adresse entre deux pointeurs génériques :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
int
block_list_write_buffer( struct block_list_head * head, void * buffer, unsigned int size )
{
	if (check(head != NULL, "Argument head is NULL")&&
		check(buffer != NULL, "Argument buffer is NULL")&&
		check(size != 0, "Argument size is invalid"))
	{	
		void * ptr_write = NULL;
		void * ptr_read = NULL;
		unsigned int free_size, size_write, buffer_move = 0;
		do
		{
			ptr_write = block_list_write_begin(head,&free_size);		
			ptr_read = block_list_get_read(head);
 
			if (size > free_size)
			{
				size_write = free_size;
			}
			else
			{
				size_write = size;
			}
			memcpy(ptr_write, (void *)((char *)buffer + buffer_move), size_write);
			block_list_write_end(head,size_write);										
 
			size -= size_write;
			buffer_move += size_write;
		}
		while (size != 0);
		return 0;
	}
	return -1;
}
la fonction block_list_write_begin retourne l'adresse du pointeur ou il faut ecrire et block_list_write_end decale ce pointeur de N octets que l'on a ecris.
par rapport a ca tout se passe bien, je vous donne d'ailleurs les 2 fonctions :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void *
block_list_write_begin( struct block_list_head * head, unsigned int * size )
{
	struct block_list_elem * elem = NULL;	
	if (check(head != NULL, "Argument head is NULL"))
	{
		if (!linked_list_is_empty(head))
		{
			*size = head->free = block_list_get_size_written(head);	
		}
		else
		{
			elem = block_pool_alloc_as( block_list_elem, head->pool );
			if (check(elem != NULL, "Block pool is empty"))
			{
				block_list_init_elem(elem);
				linked_list_append_as( head, elem );	
				*size = head->free = block_list_get_size_written(head);	
			}
		}
		return block_list_get_write(head);		
	}
	return NULL;
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
int
block_list_write_end( struct block_list_head * head, unsigned int size )
{
	if (check(head != NULL, "Argument head is NULL")&&
		check(size != 0, "Argument size is invalid"))
	{
		struct block_list_elem * elem = NULL;
		elem = linked_list_last_as( block_list_elem, head );
		elem->write += size;
 
		if ( elem->write >= block_pool_size(head->pool) )
		{
			elem = block_pool_alloc_as( block_list_elem, head->pool );
			if (check(elem != NULL, "Block pool is empty"))
			{
				block_list_init_elem(elem);
				linked_list_append_as(head,elem);
			}
		}
		return 0;
	}
	return -1;
}
au depart de mon programme j'ai deux pointeurs qui pointent sur la meme adresse , un pointeur write et un pointeur read (normal on a rien ecris ni rien lu), a l'appel de la fonction block_list_write_end ou plutot au second appel mon pointeur read est completement faussé ! il ne pointe plus sur la bonne adresse alors qu'on ne lui a rien demandé !

il semblerais que les elements de la structure contenant le pointeur read sont remplacé par des elements du buffer que je passe en parametre a la fonction block_list_write_buffer.

pour info buffer est un tableau statique d'unsigned int de taille 50.

je bloque depuis hier la dessus et je commence vraiment a secher !
merci d'avance