Problème affichage fonction récursive

Version imprimable

Bonsoir,

il m'est demandé de ré-implémenter la fonction tail avec une fonction récursive et avec des appels systèmes ; open() , read() , lseek ...

Donc mon problème est dans l'affichage du rendu, je vous laisse examiner par vous même :

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/types.h>
 
#define TAILLE 16
static int N = 10;
 
void get_file_info(const char* path, ssize_t* file_size, int* file_lines) 
{
	int i;
	int fd_source;
	int nb_line_file = 0;
	char buffer[TAILLE];
	ssize_t nb_octets_readed;
	ssize_t nb_octets_readed_final = 0;
 
 
	/* Open the file */
	fd_source = open(path, O_RDONLY);
    	if (fd_source == -1)
	{
		perror("Erreur open:");
		exit(EXIT_FAILURE);
	}
 
	/* Read the file */
	while ((nb_octets_readed = read(fd_source, buffer, TAILLE)) > 0)
	{
		/* Count number of return to the line */
		for (i=0; i<nb_octets_readed; i++)
		{
			if ( buffer[i] == '\n')
				nb_line_file++;
		}
		/* Size of the file */
		nb_octets_readed_final += nb_octets_readed;
	}
 
	*file_size = nb_octets_readed_final;
	*file_lines = nb_line_file;
 
	close(fd_source);
	return;
}
 
int get_buffer_lines(char buffer[])
{
	int i;
	int nb = 0;
	for (i=0; i<TAILLE; i++)
	{
		if ( buffer[i] == '\n')
			nb++;
	}
	return nb;	
}
 
void mread(const char* path, ssize_t* file_size, int* file_lines, int* readed_lines)
{
	int fd_source;
	int nb_lines = 0;
	int i;
	off_t pos;
	char buffer[TAILLE];	
	ssize_t nb_octets_readed;
 
	/* Recurisf / display */
	if (*readed_lines <= N)
	{
		/* Open the file */
		fd_source = open(path, O_RDONLY);
	    	if (fd_source == -1)
		{
			perror("Error open :");
			exit(EXIT_FAILURE);
		}
 
		/* Positionning the cursor */
		pos = lseek(fd_source,-(*file_size-TAILLE), SEEK_END);
		*file_size -= TAILLE; /* sbtract the size to re-set the cursor */
		printf("new file size : %ld\n",*file_size);
		if (pos == -1) 
		{
			perror("Error lseek");
			exit(EXIT_FAILURE);
		}
 
		/* Read */
		nb_octets_readed = read(fd_source, buffer, TAILLE);
		*readed_lines += get_buffer_lines(buffer);
		mread(path,file_size,file_lines,readed_lines);
	}
 
	for (i=0; i<TAILLE; i++)
	{
		printf("%c",buffer[i]);
	}
 
	close(fd_source);
 
}
 
void tail_0 (const char *path, int ntail)
{
	ssize_t file_size;
	int file_lines;
	int readed_lines = 0;
 
	/* get file info (number of lines + size of file) */
	get_file_info(path,&file_size,&file_lines);
	printf("File : %s\nFile Size : %ld\nFile Lines : %d\n",path,file_size,file_lines);
 
	/* All */
	mread(path,&file_size,&file_lines,&readed_lines);
 
 
}
 
 
int main (int argc, char *argv[])
{
	tail_0(argv[1],0);
	return 0;
}

voici le bout de code qui pose problème :

Code:

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
35
36
37
38
39
40
41
42
43
44
void mread(const char* path, ssize_t* file_size, int* file_lines, int* readed_lines)
{
	int fd_source;
	int nb_lines = 0;
	int i;
	off_t pos;
	char buffer[TAILLE];	
	ssize_t nb_octets_readed;
 
	/* Recurisf / display */
	if (*readed_lines <= N)
	{
		/* Open the file */
		fd_source = open(path, O_RDONLY);
	    	if (fd_source == -1)
		{
			perror("Error open :");
			exit(EXIT_FAILURE);
		}
 
		/* Positionning the cursor */
		pos = lseek(fd_source,-(*file_size-TAILLE), SEEK_END);
		*file_size -= TAILLE; /* sbtract the size to re-set the cursor */
		printf("new file size : %ld\n",*file_size);
		if (pos == -1) 
		{
			perror("Error lseek");
			exit(EXIT_FAILURE);
		}
 
		/* Read */
		nb_octets_readed = read(fd_source, buffer, TAILLE);
		*readed_lines += get_buffer_lines(buffer);
		mread(path,file_size,file_lines,readed_lines);
	}
 
	for (i=0; i<TAILLE; i++)
	{
		printf("%c",buffer[i]);
	}
 
	close(fd_source);
 
}

un exemple de retour :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
./mtail test.txt
File : test.txt
File Size : 111
File Lines : 15
new file size : 95
new file size : 79
new file size : 63
new file size : 47
new file size : 31
 ͟��igne12
ligne13
ligne10
ligne11
l
ligne8
ligne9
le5
ligne6
ligne7gne3
ligne4
lign

fichier test.txt

Code:

1
2
3
4
5
6
7
8
9
10
 
ligne 1
.
.
.
ligne 10
.
.
 
ligne 15

Merci de bien vouloir m'aiguiller !

01/10/2016, 11h49
dalfab

Bonjour,

au jeu des sept erreurs, je propose :
ligne 14 : fd_source = open(path, O_RDONLY|O_BINARY); Les données sont gérées octet par octet, il ne faut pas ouvrir le fichier en mode texte sous peine de lire des buffers incomplets.
ligne 22 : pos = lseek(fd_source,*file_size-TAILLE, SEEK_SET); Il faut se positionner par rapport au début car SEEK_END ne connait que la vraie position de fin du fichier.
ligne 37 : for (i=0; i<nb_octets_readed; i++) La fonction a pu lire moins d'octet que demandé, il ne faut pas en afficher plus.
ligne 42 : close(fd_source); doit être déplacée ligne 35. Il ne faut jamais fermer un fichier qui n'a jamais été ouvert.
Rien ne dit que le premier caractère affiché est aussi le premier de la ligne. Il faudra ôter des caractères après avoir recherché une ligne de plus.
Que ce passe-t-il si le nombre de lignes demandé est inférieur à celui du fichier?
Le résultat change-t-il si la toute dernière ligne ne se termine pas par un retour chariot? Donnée de spécification manquante.

Et la dernière, et non la moindre, pourquoi utiliser des fonctions qui sont obsolètes et considérées dangereuses (open,read,write) depuis 1999?! Si c'est un cours, le prof mérite la médaille d'honneur!
01/10/2016, 12h49
picodev

Citation:

Envoyé par dalfab

[...]

Et la dernière, et non la moindre, pourquoi utiliser des fonctions qui sont obsolètes et considérées dangereuses (open,read,write) depuis 1999?! Si c'est un cours, le prof mérite la médaille d'honneur!

Bonjour,

obsolètes ? Je ne crois pas, elles font toutes trois partie du standard POSIX y compris dans sa dernière mouture de 2008. Elles ne sont ni marquées obsolètes ni même obsolescentes …
01/10/2016, 13h48
dalfab

J'ai parlé un peu vite, ces fonctions ne sont plus dans la libC, cf ISO/IEC 9899.
gcc et visual studio les mettent dans <fcnt.h> avec ou sans un préfixe '_', d'autres dans <unistd.h>.
Et read est tagguée unsafe par visual (qui signale intempestivement toutes les functions de remplissage de buffer)

Elles font partie de la norme POSIX depuis ses débuts et je ne vois pas comment s'en passer quand on doit écrire un driver.

Salut

Donc déjà merci pour les retours, et désolé car je vous ai donné une version assez"brouillon" qui ne me plaisait pas du tout ....

voici une version bcp plus lisible et compréhensible (j'espère), donc le problème se situe toujours dans l'affichage, le résultat est là mais c'est un peu le bordel, et je n'arrive pas à comprendre mon erreur !

Sinon pour ce qui est de la position du lseek, l'énoncé stipule de commencer par la fin, donc pas le choix.....
Pour les appels read(),write() notre cours traite des appels systèmes donc nous devons utiliser ceux la et le prof a bien stipuler que ces appels étaient coûteux en matière de monopolisation du proc(temps), vu que ce sont des appels sys et que le tampon est assez petit, mais que c'était utile de savoir comment les utiliser !

Sinon pour ce qui est du cas de lecture incomplète dû à la taille du buffer, c'est parmi les questions posées ....

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/types.h>
 
#define TAILLE 16
static int N = 10;
 
void get_file_info(int fd_source, ssize_t* file_size, int* file_lines, int* fid) 
{
	int i;
	int nb_line_file = 0;
	char buffer[TAILLE];
	ssize_t nb_octets_readed;
	ssize_t nb_octets_readed_final = 0;
 
	/* Read the file */
	while ((nb_octets_readed = read(fd_source, buffer, TAILLE)) > 0)
	{
		/* Count number of return to the line */
		for (i=0; i<nb_octets_readed; i++)
		{
			if ( buffer[i] == '\n')
				nb_line_file++;
		}
		/* Size of the file */
		nb_octets_readed_final += nb_octets_readed;
	}
 
	*file_size = nb_octets_readed_final;
	*file_lines = nb_line_file;
 
	return;
}
 
int get_buffer_lines(char buffer[])
{
	int i;
	int nb = 0;
	for (i=0; i<TAILLE; i++)
	{
		if ( buffer[i] == '\n')
			nb++;
	}
	return nb;	
}
 
 
void mread(int fd_source, ssize_t file_size, int* readed_lines, int *actual_pos)
{
	off_t pos;
	char buffer[TAILLE];	
	ssize_t nb_octets_readed;
 
	if (*readed_lines <= N)
	{
		/* Positionning the cursor */
		pos = lseek(fd_source,(*actual_pos-file_size), SEEK_END);
		if (pos == -1) 
		{
			perror("Error lseek");
			exit(EXIT_FAILURE);
		}
		*actual_pos += TAILLE;
		printf("readed lines : %d | acutal_pos : %d\n",*readed_lines,*actual_pos);
 
		/* Read */
		nb_octets_readed = read(fd_source, buffer, TAILLE);
		*readed_lines += get_buffer_lines(buffer);
		mread(fd_source,file_size,readed_lines,actual_pos);
		write(STDOUT_FILENO, buffer, nb_octets_readed);	
	}
	else
	{
		return;
	}
 
}
 
void tail_0 (const char *path, int ntail)
{
	ssize_t file_size;
	int file_lines;
	int readed_lines = 0;
	int actual_pos = 16;
	int fd_source;	
 
	/* Open the file */
	fd_source = open(path, O_RDONLY);
    	if (fd_source == -1)
	{
		perror("Erreur open:");
		exit(EXIT_FAILURE);
	}
 
	/* get file info (number of lines + size of file + file_id) */
	get_file_info(fd_source,&file_size,&file_lines,&fd_source);
	printf("File : %s (%d) | File Size : %ld | File Lines : %d\n",path,fd_source,file_size,file_lines);
 
	/* All */
	mread(fd_source,file_size,&readed_lines,&actual_pos);
 
	close(fd_source);
}
 
 
int main (int argc, char *argv[])
{
	tail_0(argv[1],0);
	return 0;
}

EDIT

Bon mon erreur pour l'affichage était dans le fait que j’affichais après l'appel récursif !
Maintenant le problème est dans le positionnement du curseur, je vais voir ce que j'arrive à faire !

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/types.h>
 
#define TAILLE 16
static int N = 10;
 
void get_file_info(int fd_source, ssize_t* file_size, int* file_lines, int* fid) 
{
	int i;
	int nb_line_file = 0;
	char buffer[TAILLE];
	ssize_t nb_octets_readed;
	ssize_t nb_octets_readed_final = 0;
 
	/* Read the file */
	while ((nb_octets_readed = read(fd_source, buffer, TAILLE)) > 0)
	{
		/* Count number of return to the line */
		for (i=0; i<nb_octets_readed; i++)
		{
			if ( buffer[i] == '\n')
				nb_line_file++;
		}
		/* Size of the file */
		nb_octets_readed_final += nb_octets_readed;
	}
 
	*file_size = nb_octets_readed_final;
	*file_lines = nb_line_file;
 
	return;
}
 
int get_buffer_lines(char buffer[])
{
	int i;
	int nb = 0;
	for (i=0; i<TAILLE; i++)
	{
		if ( buffer[i] == '\n')
			nb++;
	}
	return nb;	
}
 
 
void mread(int fd_source, ssize_t file_size, int* readed_lines, int *actual_pos)
{
	off_t pos;
	char buffer[TAILLE];	
	ssize_t nb_octets_readed;
 
	if (*readed_lines <= N)
	{
		/* Positioning the cursor */
		pos = lseek(fd_source,*actual_pos-file_size, SEEK_END);
		if (pos == -1) 
		{
			perror("Error lseek");
			exit(EXIT_FAILURE);
		}
		*actual_pos += TAILLE;
		//printf("readed lines : %d | acutal_pos : %d\n",*readed_lines,*actual_pos);
 
		/* Read */
		nb_octets_readed = read(fd_source, buffer, TAILLE);
		*readed_lines += get_buffer_lines(buffer);
		write(STDOUT_FILENO, buffer, nb_octets_readed);	
		mread(fd_source,file_size,readed_lines,actual_pos);
 
	}
	else
	{
		return;
	}
 
}
 
void tail_0 (const char *path, int ntail)
{
	ssize_t file_size;
	int file_lines;
	int readed_lines = 0;
	int actual_pos = 0;
	int fd_source;	
 
	/* Open the file */
	fd_source = open(path, O_RDONLY);
    	if (fd_source == -1)
	{
		perror("Erreur open:");
		exit(EXIT_FAILURE);
	}
 
	/* get file info (number of lines + size of file + file_id) */
	get_file_info(fd_source,&file_size,&file_lines,&fd_source);
	printf("File : %s (%d) | File Size : %ld | File Lines : %d\n",path,fd_source,file_size,file_lines);
 
	/* All */
	mread(fd_source,file_size,&readed_lines,&actual_pos);
 
	close(fd_source);
}
 
 
int main (int argc, char *argv[])
{
	tail_0(argv[1],0);
	return 0;
}

EDIT2
Le problème est bien dans le positionnement du curseur ....
Voici ce que j'essaie de faire, mais qui n'affiche pas le bon résultat

Code:

pos = lseek(fd_source,file_size-*actual_pos, SEEK_END);

EDIT3
Voila la version final qui marche, il me reste plus qu'a bien revoir la condition d'arret pour le nombre de ligne !
Sinon mon raisonnement est bon, l'affichage apres l'appel récursif !
Voila, j'ai laissé un historique si quelqu'un en aurait besoin un jour !

Code:

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/types.h>
 
#define TAILLE 16
static int N = 10;
 
void get_file_info(int fd_source, ssize_t* file_size, int* file_lines, int* fid) 
{
	int i;
	int nb_line_file = 0;
	char buffer[TAILLE];
	ssize_t nb_octets_readed;
	ssize_t nb_octets_readed_final = 0;
 
	/* Read the file */
	while ((nb_octets_readed = read(fd_source, buffer, TAILLE)) > 0)
	{
		/* Count number of return to the line */
		for (i=0; i<nb_octets_readed; i++)
		{
			if ( buffer[i] == '\n')
				nb_line_file++;
		}
		/* Size of the file */
		nb_octets_readed_final += nb_octets_readed;
	}
 
	*file_size = nb_octets_readed_final;
	*file_lines = nb_line_file;
 
	return;
}
 
int get_buffer_lines(char buffer[])
{
	int i;
	int nb = 0;
	for (i=0; i<TAILLE; i++)
	{
		if ( buffer[i] == '\n')
			nb++;
	}
	return nb;	
}
 
 
void mread(int fd_source, ssize_t file_size, int* readed_lines, int *actual_pos)
{
	off_t pos;
	char buffer[TAILLE];	
	ssize_t nb_octets_readed;
 
	if (*readed_lines <= N+1)
	{
		/* Positioning the cursor */
		pos = lseek(fd_source,file_size-*actual_pos, SEEK_END);
		if (pos == -1) 
		{
			perror("Error lseek");
			exit(EXIT_FAILURE);
		}
		*actual_pos += TAILLE;
 
		/* Read */
		nb_octets_readed = read(fd_source, buffer, TAILLE);
		*readed_lines += get_buffer_lines(buffer);
		mread(fd_source,file_size,readed_lines,actual_pos);
		write(STDOUT_FILENO, buffer, nb_octets_readed);
 
	}
	else
	{
		return;
	}
 
}
 
void tail_0 (const char *path, int ntail)
{
	ssize_t file_size;
	int file_lines;
	int readed_lines = 0;
	int actual_pos = 0;
	int fd_source;	
 
	/* Open the file */
	fd_source = open(path, O_RDONLY);
    	if (fd_source == -1)
	{
		perror("Erreur open:");
		exit(EXIT_FAILURE);
	}
 
	/* get file info (number of lines + size of file + file_id) */
	get_file_info(fd_source,&file_size,&file_lines,&fd_source);
 
	/* All */
	mread(fd_source,file_size,&readed_lines,&actual_pos);
 
	close(fd_source);
}
 
 
int main (int argc, char *argv[])
{
	tail_0(argv[1],0);
	return 0;
}