Discussion :

[mikhailo]

Bah surtout, merci de votre aide! Je comprends bien mieux les trucs maintenant; j'ai un ami qui m'a un peu briefé sur les pointeurs, et grâce à toi, je vois bien mieux le fonctionnement de malloc() et autres amis.

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
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
 
 
#define DICO "lefff-2.1.txtstd.txtsorted.txt"
#define TAILLE_LIGNE_MAX 200
 
 
 
 
 
/*
Extrait une partie du mot, comprise entre les indices i et j. On suppose:
i < j;
j <= (strlen(mot) - 1);
*/
 
char* extractPart(char mot[], int i, int j, char partie[])
{
	partie = strndup(mot+i, j+1);
 
	return partie;
}
 
 
 
 
 
 
/*
Fonction concaténant en un mot deux mots prix en argument.
*/
char* concateneMots(char mot1[], char mot2[], char concatenation[])
{
	strcpy(concatenation, mot1);
	strcat(concatenation, mot2);
 
	return concatenation;
}
 
 
 
 
 
 
 
 
 
 
 
 
int nombreLignes(char chemin[])
{
	int nombre_lignes = 0;
	char c[200];
 
	FILE* fichier = NULL;
	fichier = fopen(chemin, "r");
 
	while (fgets(c, TAILLE_LIGNE_MAX, fichier) != NULL)
	{
		nombre_lignes++;
	}
 
	fclose(fichier);
	return nombre_lignes;
}
 
 
 
 
 
 
/*
accoutrée		v	[pred='accoutrer_____1<obj:(sn),objde:(de-sn),suj:(par-sn)>',cat=v,@passive,@être,@Kfs]
*/
 
char* partOfSpeech(char ligne_dico[], char classeg[])
{
	char* mot = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
	int* nombre = (int*)malloc(TAILLE_LIGNE_MAX * sizeof(int));
 
	sscanf(ligne_dico, "%s %d %s", mot, nombre, classeg);
	if (*nombre == 0)
	{
		sscanf(ligne_dico, "%s %s", mot, classeg);
	}
 
	free(nombre);
	free(mot);
	return classeg;
}
 
/*
verbe, adjectif, pronom, nom commun, (nom propre), adverbe, *conjonction de coordinations, *préposition
v	adj	pro		nc	np		adv	coo				prep
conjonction de subordination,			determinant,
csu(afin que)			cld(lui)	det
 
*/
 
 
 
 
/*
Fonction qui extrait le mot de la ligne du dictionnaire correspondante.
*/
char* getMot(char ligne_dico[], char mot_recup[])
{
	sscanf(ligne_dico, "%s", mot_recup);
	return mot_recup;
}
 
 
 
 
 
 
 
 
 
 
char* rechercheDichotomique(char mot[], FILE* dictionnaire, char ligne_renvoyee[])
{
	int stop = 0;
	int position_current = 0;
	int n = 2;
	int signe = 1;
	int etape = 0;
	int modificateur = 0;
	int k = 0;
	int l = 0;
	int leng = 0;
	int taille_dico;
	char aux[TAILLE_LIGNE_MAX];
	char mot_lu[TAILLE_LIGNE_MAX];
	char c[1];
 
	fseek(dictionnaire, 0, SEEK_END);
	taille_dico = ftell(dictionnaire);
	fseek(dictionnaire, 0, SEEK_SET);
 
	while (stop != 1)
	{
		if (position_current%2 == 0)
		{
			modificateur = taille_dico/n;
		}
		else
		{
			modificateur = ((int)taille_dico/(n)) + 1;
		}
 
		if (modificateur < k)
		{
			modificateur = k;
		}
 
		position_current = position_current + signe*(modificateur);
 
		if (position_current < 0)
		{
			position_current = position_current + modificateur - l;
		}
 
 
		etape = etape + 1;
		n = n * 2;
 
		fseek(dictionnaire, position_current, SEEK_SET);
		l = 0;
 
		while((c[0] = fgetc(dictionnaire)) != '\n')
       		{	
    			fseek(dictionnaire, -2, SEEK_CUR);
			l = l + 1;
 
		}
		position_current = position_current - l;		
 
 
		fscanf(dictionnaire, "%s", mot_lu);
		leng = strlen(mot_lu);
/*
		printf("etape %d, position dans le fichier: %d, pas de la recherche: %d\n", etape, position_current, modificateur);
		printf("mot lu: %s\n", mot_lu);
		printf("comparaison entre %s et '%s': %d\n\n", mot_lu, mot, strcmp(mot_lu, mot));
*/		
		if (etape > 25)
		{
			fseek(dictionnaire, 0, SEEK_SET);
			return NULL;
		}
		if (strcmp(mot_lu, mot) == 1)
		{
			signe = -1;
			k = 24;
			while ((c[0] = fgetc(dictionnaire)) != '\n')
			{
				k = k + 1;
			}
 
			fseek(dictionnaire, -k, SEEK_CUR);
 
		}
		if (strcmp(mot_lu, mot) == -1)
		{
			signe = 1;
			k = 24;
			while ((c[0] = fgetc(dictionnaire)) != '\n')
			{
				k = k + 1;
			}
 
			fseek(dictionnaire, -k, SEEK_CUR);
 
		}		
		if (strcmp(mot_lu, mot) == 0)
		{
/*			printf("%s = %s, recherche terminee en %d etapes!\n", mot_lu, mot, etape);*/
			stop = 1;
		}
	}	
 
	fseek(dictionnaire, -leng, SEEK_CUR);
	fgets(aux, TAILLE_LIGNE_MAX, dictionnaire);
	strcpy(ligne_renvoyee, aux);
/*	
	printf("taille du fichier: %d octets\n", taille_dico);
*/	
	fseek(dictionnaire, 0, SEEK_SET);
	return ligne_renvoyee;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
void chercheAmbiguite(char mot[], char exception1[], char exception2[], FILE* dictionnaire, char ligne_renvoyee[])
{
	int i = 0;
	int length = strlen(mot);
	char* part1;
	char* part2;
	char* partie = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
	for (i = 0; i < length; i++)
	{
		part1 = extractPart(mot, 0, i, partie);
		part2 = extractPart(mot, i+1, length-1, partie);
 
		if ((strcmp(part1, exception1) != 0) && (strcmp(part1, exception2) != 0) && (strcmp(part2, exception1) != 0) && (strcmp(part2, exception2) != 0))
		{
/*
			printf("%s %s\n", part1, part2);
*/
			if ((rechercheDichotomique(part1, dictionnaire, ligne_renvoyee) != NULL) && (strlen(part1) > 1))
			{
				if ((rechercheDichotomique(part2, dictionnaire, ligne_renvoyee) != NULL) && (strlen(part2) > 1))
				{
					printf("%s %s   <<< concaténation initiale\n%s %s   <<< partitionnement alternatif; URL équivoque valable!\n", exception1, exception2, part1, part2);
				}
			}
		}
	}
	free(partie);
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
int main(int argc, char ** argv)
{	
	int i = 0;
	int nombre_lignes;
	char* result;
	char* result2;
	char ligne_lue[TAILLE_LIGNE_MAX];
	char* mot_recup = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
	FILE* fichier = NULL;
 
/*Déclaration des variables relatives à rechercheDichotomique */
	FILE* FICHIER_DICO;	
	char* LIGNE_RENVOYEE = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
/*Déclaration des variables relatives à concateneMots */
	char* CONCATENATION = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
/*Déclaration des variables relatives à partOfSpeech */
	char* classeg = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
	if (argc != 2)
	{
		printf("Un seul mot en argument à la fois, merci.\n");
		free(mot_recup);
		free(LIGNE_RENVOYEE);
		free(CONCATENATION);
		free(classeg);
		return 0;
	}
 
	FICHIER_DICO = fopen(DICO, "r");
 
	result = rechercheDichotomique(argv[1], FICHIER_DICO, LIGNE_RENVOYEE);
 
	if (result != NULL)
	{
		result2 = partOfSpeech(result, classeg);
		printf("%s", result);
		printf("Classe grammaticale = %s\n", result2);
	}
	else
	{
		printf("Le mot propose ne fait pas partie du dictionnaire :'-)\n");
	}
 
	nombre_lignes = nombreLignes(DICO);	
 
	fichier = fopen(DICO, "r");
 
	for (i = 0; i < nombre_lignes; i++)
	{
		fgets(ligne_lue, TAILLE_LIGNE_MAX, fichier);
		getMot(ligne_lue, mot_recup);
		if (i%1000 == 0)
		{
			printf("%dème mot lu = %s\n", i, mot_recup);
		}
		chercheAmbiguite(concateneMots(argv[1], mot_recup, CONCATENATION), argv[1], mot_recup, FICHIER_DICO, LIGNE_RENVOYEE);
		chercheAmbiguite(concateneMots(mot_recup, argv[1], CONCATENATION), mot_recup, argv[1], FICHIER_DICO, LIGNE_RENVOYEE);
	}
 
	printf("Recherche terminée! :'-)\n");
 
	fclose(FICHIER_DICO);
	fclose(fichier);
	free(LIGNE_RENVOYEE);
	free(CONCATENATION);
	free(classeg);
	return 0;
}

Et maintenant, aucun warning à la compilation, même avec -Wall -ansi -pedantic, et j'ai également remplacé le renvoi du string "*error" par "return NULL", comme vous m'avez dit. Pour ce qui est de tes trois dernières remarques, Sve@r, je corrigerai ça lundi; weekend chargé!

Donc merci à vous... et "résolu" enfin!

[gl]

Et maintenant, aucun warning à la compilation, même avec -Wall -ansi -pedantic

Il peut être intéressant de rajouter -Wextra (ou -W selon la version de gcc) qui active d'autres warnings (car Wall, contrairement à ce que son nom laisse penser, n'active pas tous les warning) qui peuvent être intéressant.

Pour ma part le compilateur me sort un warning à la ligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

nombre_lignes = nombreLignes(DICO);

Le prototype de nombreLignes devrait être :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

int nombreLignes(const char chemin[])

Au passage, il est surprenant de compiler avec l'option -ansi dont le rôle est de désactiver les extensions GNU et dans le même temps d'utiliser _GNU_SOURCE qui permet au contraire d'activer ces extensions. Autant compiler avec l'option _std=gnu99 à la place de -ansi si tu souhaites utiliser les extensions GNU.

[mikhailo]

Merci pour le -Wextra; j'ai fait la modif que tu as proposée. En fait, ça ne me faisait aucun warning quand même, mais bon! Je pense que ça doit dépendre des versions de gcc (?).

Quant à la compilation avec -ansi et #define _GNU_SOURCE à la fois, eh bien... c'est juste que je ne savais pas ce que -ansi impliquait, on m'a juste dit que c'était bien =) Et _GNU_SOURCE, j'en ai besoin pour la fonction strndup().

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
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
 
 
#define DICO "lefff-2.1.txtstd.txtsorted.txt"
#define TAILLE_LIGNE_MAX 200
 
 
 
 
 
/*
Extrait une partie du mot, comprise entre les indices i et j. On suppose:
i < j;
j <= (strlen(mot) - 1);
*/
 
char* extractPart(char mot[], int i, int j, char partie[])
{
	partie = strndup(mot+i, j+1);
 
	return partie;
}
 
 
 
 
 
 
/*
Fonction concaténant en un mot deux mots prix en argument.
*/
char* concateneMots(char mot1[], char mot2[], char concatenation[])
{
	sprintf(concatenation, "%s%s", mot1, mot2);
 
	return concatenation;
}
 
 
 
 
 
 
 
 
 
 
 
 
int nombreLignes(const char chemin[])
{
	int nombre_lignes = 0;
	char c[200];
 
	FILE* fichier = NULL;
	fichier = fopen(chemin, "r");
 
	while (fgets(c, TAILLE_LIGNE_MAX, fichier) != NULL)
	{
		nombre_lignes++;
	}
 
	fclose(fichier);
	return nombre_lignes;
}
 
 
 
 
 
 
/*
accoutrée		v	[pred='accoutrer_____1<obj:(sn),objde:(de-sn),suj:(par-sn)>',cat=v,@passive,@être,@Kfs]
*/
 
char* partOfSpeech(char ligne_dico[], char classeg[])
{
	char mot[TAILLE_LIGNE_MAX];
	int* nombre;
 
	sscanf(ligne_dico, "%s %d %s", mot, nombre, classeg);
	if (nombre == 0)
	{
		sscanf(ligne_dico, "%s %s", mot, classeg);
	}
 
	return classeg;
}
 
/*
verbe, adjectif, pronom, nom commun, (nom propre), adverbe, *conjonction de coordinations, *préposition
v	adj	pro		nc	np		adv	coo				prep
conjonction de subordination,			determinant,
csu(afin que)			cld(lui)	det
 
*/
 
 
 
 
/*
Fonction qui extrait le mot de la ligne du dictionnaire correspondante.
*/
char* getMot(char ligne_dico[], char mot_recup[])
{
	sscanf(ligne_dico, "%s", mot_recup);
	return mot_recup;
}
 
 
 
 
 
 
 
 
 
 
char* rechercheDichotomique(char mot[], FILE* dictionnaire, char ligne_renvoyee[])
{
	int stop = 0;
	int position_current = 0;
	int n = 2;
	int signe = 1;
	int etape = 0;
	int modificateur = 0;
	int k = 0;
	int l = 0;
	int leng = 0;
	int taille_dico;
	char aux[TAILLE_LIGNE_MAX];
	char mot_lu[TAILLE_LIGNE_MAX];
	char c[1];
 
	fseek(dictionnaire, 0, SEEK_END);
	taille_dico = ftell(dictionnaire);
	fseek(dictionnaire, 0, SEEK_SET);
 
	while (stop != 1)
	{
		if (position_current%2 == 0)
		{
			modificateur = taille_dico/n;
		}
		else
		{
			modificateur = ((int)taille_dico/(n)) + 1;
		}
 
		if (modificateur < k)
		{
			modificateur = k;
		}
 
		position_current = position_current + signe*(modificateur);
 
		if (position_current < 0)
		{
			position_current = position_current + modificateur - l;
		}
 
 
		etape = etape + 1;
		n = n * 2;
 
		fseek(dictionnaire, position_current, SEEK_SET);
		l = 0;
 
		while((c[0] = fgetc(dictionnaire)) != '\n')
       		{	
    			fseek(dictionnaire, -2, SEEK_CUR);
			l = l + 1;
 
		}
		position_current = position_current - l;		
 
 
		fscanf(dictionnaire, "%s", mot_lu);
		leng = strlen(mot_lu);
/*
		printf("etape %d, position dans le fichier: %d, pas de la recherche: %d\n", etape, position_current, modificateur);
		printf("mot lu: %s\n", mot_lu);
		printf("comparaison entre %s et '%s': %d\n\n", mot_lu, mot, strcmp(mot_lu, mot));
*/		
		if (etape > 25)
		{
			fseek(dictionnaire, 0, SEEK_SET);
			return NULL;
		}
		if (strcmp(mot_lu, mot) == 1)
		{
			signe = -1;
			k = 24;
			while ((c[0] = fgetc(dictionnaire)) != '\n')
			{
				k = k + 1;
			}
 
			fseek(dictionnaire, -k, SEEK_CUR);
 
		}
		if (strcmp(mot_lu, mot) == -1)
		{
			signe = 1;
			k = 24;
			while ((c[0] = fgetc(dictionnaire)) != '\n')
			{
				k = k + 1;
			}
 
			fseek(dictionnaire, -k, SEEK_CUR);
 
		}		
		if (strcmp(mot_lu, mot) == 0)
		{
/*			printf("%s = %s, recherche terminee en %d etapes!\n", mot_lu, mot, etape);*/
			stop = 1;
		}
	}	
 
	fseek(dictionnaire, -leng, SEEK_CUR);
	fgets(aux, TAILLE_LIGNE_MAX, dictionnaire);
	strcpy(ligne_renvoyee, aux);
/*	
	printf("taille du fichier: %d octets\n", taille_dico);
*/	
	fseek(dictionnaire, 0, SEEK_SET);
	return ligne_renvoyee;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
void chercheAmbiguite(char mot[], char exception1[], char exception2[], FILE* dictionnaire, char ligne_renvoyee[])
{
	int i = 0;
	int length = strlen(mot);
	char* part1;
	char* part2;
	char* partie = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
	for (i = 0; i < length; i++)
	{
		part1 = extractPart(mot, 0, i, partie);
		part2 = extractPart(mot, i+1, length-1, partie);
 
		if ((strcmp(part1, exception1) != 0) && (strcmp(part1, exception2) != 0) && (strcmp(part2, exception1) != 0) && (strcmp(part2, exception2) != 0))
		{
/*
			printf("%s %s\n", part1, part2);
*/
			if ((rechercheDichotomique(part1, dictionnaire, ligne_renvoyee) != NULL) && (strlen(part1) > 1))
			{
				if ((rechercheDichotomique(part2, dictionnaire, ligne_renvoyee) != NULL) && (strlen(part2) > 1))
				{
					printf("%s %s   <<< concaténation initiale\n%s %s   <<< partitionnement alternatif; URL équivoque valable!\n", exception1, exception2, part1, part2);
				}
			}
		}
	}
	free(partie);
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
int main(int argc, char ** argv)
{	
	int i = 0;
	int nombre_lignes;
	char* result;
	char* result2;
	char ligne_lue[TAILLE_LIGNE_MAX];
	char* mot_recup = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
	FILE* fichier = NULL;
 
/*Déclaration des variables relatives à rechercheDichotomique */
	FILE* FICHIER_DICO;	
	char* ligne_renvoyee = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
/*Déclaration des variables relatives à concateneMots */
	char* concatenation = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
/*Déclaration des variables relatives à partOfSpeech */
	char classeg[TAILLE_LIGNE_MAX];
 
 
	if (argc != 2)
	{
		printf("Un seul mot en argument à la fois, merci.\n");
		free(mot_recup);
		free(ligne_renvoyee);
		free(concatenation);
		free(classeg);
		return 0;
	}
 
	FICHIER_DICO = fopen(DICO, "r");
 
	result = rechercheDichotomique(argv[1], FICHIER_DICO, ligne_renvoyee);
 
	if (result != NULL)
	{
		result2 = partOfSpeech(result, classeg);
		printf("%s", result);
		printf("Classe grammaticale = %s\n", result2);
	}
	else
	{
		printf("Le mot propose ne fait pas partie du dictionnaire :'-)\n");
	}
 
	nombre_lignes = nombreLignes(DICO);	
 
	fichier = fopen(DICO, "r");
 
	for (i = 0; i < nombre_lignes; i++)
	{
		fgets(ligne_lue, TAILLE_LIGNE_MAX, fichier);
		getMot(ligne_lue, mot_recup);
		if (i%1000 == 0)
		{
			printf("%dème mot lu = %s\n", i, mot_recup);
		}
		chercheAmbiguite(concateneMots(argv[1], mot_recup, concatenation), argv[1], mot_recup, FICHIER_DICO, ligne_renvoyee);
		chercheAmbiguite(concateneMots(mot_recup, argv[1], concatenation), mot_recup, argv[1], FICHIER_DICO, ligne_renvoyee);
	}
 
	printf("Recherche terminée! :'-)\n");
 
	fclose(FICHIER_DICO);
	fclose(fichier);
	free(ligne_renvoyee);
	free(concatenation);
	return 0;
}

Les trois points relevés par Sve@r sont aussi maintenant corrigés, sauf une petite chose que je ne comprends pas:

1) dans la fonction partOfSpeech, tu fais des malloc de zones à taille fixes. Autant les remplacer par des tableaux. Pareil pour la fonction chercheAmbiguite

Dans celle-ci, il n'y a qu'un seul malloc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	char* partie = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));

et si je le remplace par un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	char partie[TAILLE_LIGNE_MAX];

ou même

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	char partie[TAILLE_LIGNE_MAX * sizeof(char)];

j'ai un segfault, alors que, ce que l'on met dedans ne dépasse jamais même TAILLE_MAX_LIGNE, sans parler de TAILLE_MAX_LIGNE * sizeof(char). En revanche, l'utilisation de malloc() évite ce problème. Si vous pouviez m'expliquer la chose, please? =)

[gl]

Merci pour le -Wextra; j'ai fait la modif que tu as proposée. En fait, ça ne me faisait aucun warning quand même, mais bon! Je pense que ça doit dépendre des versions de gcc (?).

C'est surtout que je me suis planté. L'option -Wextra n'active pas ce warning non plus, il faut l'ajout spécifiquement (-Wwrite-strings).

Dans celle-ci, il n'y a qu'un seul malloc:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	char* partie = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));

et si je le remplace par un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	char partie[TAILLE_LIGNE_MAX];

ou même

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

	char partie[TAILLE_LIGNE_MAX * sizeof(char)];

j'ai un segfault

As-tu bien enlevé l'appel à free() ?

Au passage, avec la gestion de mémoire comme tu le fais dans extractPart() et chercheAmbiguite(), tu as des fuites de mémoire.
Tu alloues plusieurs fois (malloc + n appels à strndup dans extractPart) mais tu ne libères qu'une fois (la mémoire qui correspond au malloc).

alors que, ce que l'on met dedans ne dépasse jamais même TAILLE_MAX_LIGNE, sans parler de TAILLE_MAX_LIGNE * sizeof(char).

Les deux expressions sont strictement égales car par définition sizeof(char) vaut 1.


EDIT : petite correction suite à une lecture trop rapide.

[gl]

Je viens de faire quelques tests avec un seulement un extrait du dictionnaire et un superviseur d'allocation mémoire[1] et, indépendamment des fuites mémoires [2], je suis tombé sur quelques problèmes :

• La recherche dichotomique n'arrive pas à trouver le premier mot du dictionnaire s'il n'y a pas une ligne vide avant.
• Dans chercheAmbiguite(), le programme a lancé une recherche dichotomique sur un mot non présent dans le fichier et là, il part en vrille. On se retrouve avec des position_current négatifs, on part en boucle infinie et on va jardiner en mémoire.

Je n'ai pas poussé plus en avant l'analyse (et il n'est pas exclu que ce soit mon fichier partiel qui est mal formé).

EDIT : j'obtiens le second problème également en saisissant un mot non présent.

EDIT bis : il semble que ce ne soit pas le même problème dans les deux cas. Et après avoir tracé un peu plus, ce n'est peut être finalement pas dans rechercheDichotomique() que ça part en vrille.

[1] En l'occurrence MSS.
[2] Ayant du stoppé le programme en cours d'exécution, le test n'est pas très concluant à ce niveau là.

[gl]

Une autre petite remarque, sur des fichiers ouverts en mode texte, le comportement de fseek() n'est garanti que si l'origine est SEEK_SET et l'offset 0 ou une valeur retournée par ftell().

L'utilisation que tu en fais ici n'est pas correcte vue de la norme et absolument pas portable.
Par exemple, en faisant mes tests (sous Windows), les informations retournées par rechercheDichotomique() sont systématiquement incorrectes (fin de la ligne précédente);

Au passage, tu ne testes toujours pas le retour de fopen() (ayant mis le fichier au mauvais endroit lors de mes tests, je suis tombé sur le problème).

[mikhailo]

Bonjour,

Merci pour le temps que tu as consacré à ces tests et à mon prog. Pour ce qui est des histoires de etractPart et concateneMots: par souci d'optimisation (car sur un dico de 500k mots, avec des options de recherche supplémentaires comme détection de mots de liaison entre deux parties, la recherche totale prend dans les 8h) j'ai remplacé les appels à ces fonctions par l'intégration directe dans le code de strndup() et de sprintf(), même si ça n'a pas aidé beaucoup. Donc plus de problèmes de ce côté là.

Pour ce qui est de la rechercheDichotomique():

• Il y avait effectivement un petit souci, mais pas là où tu disais; elle gérait mal quand le curseur arrivait aux derniers mots du fichier (chez moi, du moins). C'est corrigé!
• La fonction arrive au début de la ligne en déplaçant le curseur en arrière et en comptant les caractères jusqu'à rencontrer un '\n'; c'est pour ça qu'il faut que la première ligne du dico ne contienne que le '\n'.
• Le test du résultat de fopen() est à venir, je rajouterai ça plus tard.
• Pour ce qui est des boucles infinies, c'est étrange, car la boucle principale s'arrête au bout de 25 tours max, et les boucles annexes recherchant les fins de ligne s'arrêtent toujours également, puisque le fichier commence par '\n', se finit par '\n', et qu'à la fin de chaque ligne on a '\n' aussi. Si tu pouvais m'en dire plus, ce serait chouette!
• Quant à position_current négatif et jardinage en mémoire, je pense que je sais d'où ça vient. Sous linux, quand fseek() a une valeur négative, il "ricoche" du début de fichier et se retrouve donc dans les valeurs positives. Puisque ça servait plus ou moins ma cause, je n'y avais pas touché, mais du coup j'ai modifié un peu la gestion des cas où position_current dépasse les limites du fichier en bas ou en haut.
• Et si tu peux m'en dire plus concernant le comportement de fseek() sous windows, j'en serai ravi =)

Voilà donc la new version:

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
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
 
 
#define DICO "lefff-2.1.txtstd.txtsorted.txt"
#define OUTPUT "resultats.txt"
#define TAILLE_LIGNE_MAX 200
 
 
 
 
 
int nombreLignes(const char chemin[])
{
	int nombre_lignes = 0;
	char c[200];
 
	FILE* fichier = NULL;
	fichier = fopen(chemin, "r");
 
	while (fgets(c, TAILLE_LIGNE_MAX, fichier) != NULL)
	{
		nombre_lignes++;
	}
 
	fclose(fichier);
	return nombre_lignes;
}
 
 
 
 
 
 
/*
accoutrée		v	[pred='accoutrer_____1<obj:(sn),objde:(de-sn),suj:(par-sn)>',cat=v,@passive,@être,@Kfs]
*/
 
char* partOfSpeech(char ligne_dico[], char classeg[])
{
	char mot[TAILLE_LIGNE_MAX];
	int* nombre = malloc(sizeof(int));
	sscanf(ligne_dico, "%s %d %s", mot, nombre, classeg);
	if (*nombre == 0)
	{
		sscanf(ligne_dico, "%s %s", mot, classeg);
 
	}
 
	free(nombre);
	return classeg;
}
 
/*
verbe, adjectif, pronom, nom commun, (nom propre), adverbe, *conjonction de coordinations, *préposition
v	adj	pro		nc	np		adv	coo				prep
conjonction de subordination,			determinant,
csu(afin que)			cld(lui)	det
 
*/
 
 
 
 
 
 
 
char* rechercheDichotomique(char mot[], FILE* dictionnaire, char ligne_renvoyee[])
{
	int stop = 0;
	int position_current = 0;
	int n = 2;
	int signe = 1;
	int etape = 0;
	int modificateur = 0;
	int k = 0;
	int l = 0;
	int leng = 0;
	int taille_dico;
	int pos_prec;
	char aux[TAILLE_LIGNE_MAX];
	char mot_lu[TAILLE_LIGNE_MAX];
	char c[1];
 
/*	printf("recherche de\"%s\" lancée\n", mot);*/
 
	fseek(dictionnaire, 0, SEEK_END);
	taille_dico = ftell(dictionnaire);
	fseek(dictionnaire, 0, SEEK_SET);
 
	while (stop != 1)
	{
		if (position_current%2 == 0)
		{
			modificateur = taille_dico/n;
		}
		else
		{
			modificateur = ((int)taille_dico/(n)) + 1;
		}
 
		if (modificateur < k)
		{
			modificateur = k;
		}
 
		pos_prec = position_current;
		position_current = position_current + signe*(modificateur);
 
		if (position_current < 0)
		{
			position_current = (int)(pos_prec/2);
		}
 
		if (position_current >= taille_dico)
		{
			position_current = pos_prec + (int)((taille_dico - pos_prec)/2);
		}
 
		etape = etape + 1;
		n = n * 2;
 
		fseek(dictionnaire, position_current, SEEK_SET);
		l = 0;
 
		while((c[0] = fgetc(dictionnaire)) != '\n')
       		{	
    			fseek(dictionnaire, -2, SEEK_CUR);
			l = l + 1;
 
		}
		position_current = position_current - l;		
 
 
		fscanf(dictionnaire, "%s", mot_lu);
		leng = strlen(mot_lu);
/*
		printf("etape %d, position dans le fichier: %d, pas de la recherche: %d\n", etape, position_current, modificateur);
		printf("mot lu: %s\n", mot_lu);
		printf("comparaison entre %s et '%s': %d\n\n", mot_lu, mot, strcmp(mot_lu, mot));
*/		
		if (etape > 30)
		{
			fseek(dictionnaire, 0, SEEK_SET);
			return NULL;
		}
		if (strcmp(mot_lu, mot) == 1)
		{
			signe = -1;
			k = 24;
			while ((c[0] = fgetc(dictionnaire)) != '\n')
			{
				k = k + 1;
			}
 
			fseek(dictionnaire, -k, SEEK_CUR);
			continue;
 
		}
		if (strcmp(mot_lu, mot) == -1)
		{
			signe = 1;
			k = 24;
			while ((c[0] = fgetc(dictionnaire)) != '\n')
			{
				k = k + 1;
			}
 
			fseek(dictionnaire, -k, SEEK_CUR);
			continue;
 
		}		
		if (strcmp(mot_lu, mot) == 0)
		{
/*			printf("%s = %s, recherche terminee en %d etapes!\n", mot_lu, mot, etape);*/
			stop = 1;
		}
	}	
 
	fseek(dictionnaire, -leng, SEEK_CUR);
	fgets(aux, TAILLE_LIGNE_MAX, dictionnaire);
	strcpy(ligne_renvoyee, aux);
/*	
	printf("taille du fichier: %d octets\n", taille_dico);
*/	
	fseek(dictionnaire, 0, SEEK_SET);
	return ligne_renvoyee;
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
void chercheAmbiguite(char mot[], char exception1[], char exception2[], FILE* dictionnaire, FILE* fichier_resultat, char ligne_renvoyee[])
{
	int i = 0;
	int length = strlen(mot);
	char* part1;
	char* part2;
 
	for (i = 0; i < length; i++)
	{
		part1 = strndup(mot, i+1);
		part2 = strndup(mot+i+1, length-1);
 
		if ((strcmp(part1, exception1) != 0) && (strcmp(part2, exception2) != 0))
		{
/*
			printf("%s %s\n", part1, part2);
*/
			if (rechercheDichotomique(part1, dictionnaire, ligne_renvoyee) != NULL)
			{
				if (rechercheDichotomique(part2, dictionnaire, ligne_renvoyee) != NULL)
				{
					fprintf(fichier_resultat, "%s %s   <<< concaténation initiale\n%s %s   <<< partitionnement alternatif; URL équivoque valable!\n", exception1, exception2, part1, part2);
				}
			}
		}
	}
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
int main(int argc, char ** argv)
{	
	int i = 0;
	int nombre_lignes;
	char* result;
	char* result2;
	char ligne_lue[TAILLE_LIGNE_MAX];
	char* mot_recup = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
	char* concatenation = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
	FILE* fichier = NULL;
	FILE* dictionnaire_link = NULL;
	FILE* fichier_resultat = NULL;
 
/*Déclaration des variables relatives à rechercheDichotomique */
	FILE* FICHIER_DICO;	
	char* ligne_renvoyee = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
/*Déclaration des variables relatives à partOfSpeech */
	char* classeg = (char*)malloc(TAILLE_LIGNE_MAX * sizeof(char));
 
 
 
	if (argc != 2)
	{
		printf("Un seul mot en argument à la fois, merci.\n");
		free(mot_recup);
		free(ligne_renvoyee);
		free(concatenation);
		free(classeg);
		return 0;
	}
 
	FICHIER_DICO = fopen(DICO, "r");
 
	result = rechercheDichotomique(argv[1], FICHIER_DICO, ligne_renvoyee);
 
	if (result != NULL)
	{
		result2 = partOfSpeech(result, classeg);
		printf("%s", result);
		printf("Classe grammaticale = %s\n", result2);
	}
	else
	{
		printf("Le mot propose ne fait pas partie du dictionnaire :'-)\n");
	}
 
	nombre_lignes = nombreLignes(DICO);	
 
	fichier = fopen(DICO, "r");
	dictionnaire_link = fopen(LINK, "r");
	fichier_resultat = fopen(OUTPUT, "w");
 
	for (i = 0; i < nombre_lignes; i++)
	{
		fgets(ligne_lue, TAILLE_LIGNE_MAX, fichier);
		sscanf(ligne_lue, "%s", mot_recup);
		if (i%1000 == 0)
		{
			printf("%dème mot lu: %s\n", i, mot_recup);
		}
		sprintf(concatenation, "%s%s", argv[1], mot_recup);
		chercheAmbiguite(concatenation, argv[1], mot_recup, FICHIER_DICO, dictionnaire_link, fichier_resultat, ligne_renvoyee);
		sprintf(concatenation, "%s%s", mot_recup, argv[1]);
		chercheAmbiguite(concatenation, mot_recup, argv[1], FICHIER_DICO, dictionnaire_link, fichier_resultat, ligne_renvoyee);
	}
 
	printf("Recherche terminée! :'-)\n");
 
	fclose(FICHIER_DICO);
	fclose(fichier);
	free(ligne_renvoyee);
	free(concatenation);
	free(classeg);
	return 0;
}

J'ai inclus dans mon code une nouvelle fonctionnalité (recherche de mots de liaison entre les deux segmentations), mais comme ça demande d'avoir un fichier texte supplémentaire et tout ça, j'ai enlevé du code ce qui s'y rapportait. Donc si j'ai oublié quelque chose et ça bugge à la compilation, c'est qu'il doit y avoir quelque chose de trop quelque part =)

[gl]

Pour ce qui est des histoires de etractPart et concateneMots: par souci d'optimisation (car sur un dico de 500k mots, avec des options de recherche supplémentaires comme détection de mots de liaison entre deux parties, la recherche totale prend dans les 8h) j'ai remplacé les appels à ces fonctions par l'intégration directe dans le code de strndup() et de sprintf(), même si ça n'a pas aidé beaucoup. Donc plus de problèmes de ce côté là.

Ça ne m'étonne pas que ça n'ait pas beaucoup aidé. Le temps pris par l'appel de fonction supplémentaire est relativement faible par rapport aux accès fichier.
L'accès à un fichier est une opération plutôt longue, surtout en y accédant de manière non séquentiel comme tu le fais (tu perds les avantages de la mise en cache, du positionnement anticipé de la tête de lecture, etc.).
Selon le système de fichier utilisé et la façon dont s'effectue le fseek(), l'utilisation d'une recherche dichotomique peut même être une mauvaise solution [1].

Ceci étant, tu as encore la fuite mémoire sur ce qui est alloué par strndup.

La fonction arrive au début de la ligne en déplaçant le curseur en arrière et en comptant les caractères jusqu'à rencontrer un '\n'; c'est pour ça qu'il faut que la première ligne du dico ne contienne que le '\n'.

OK, c'est le comportement attendu du programme. Mon fichier n'était donc pas correct.

Pour ce qui est des boucles infinies, c'est étrange, car la boucle principale s'arrête au bout de 25 tours max, et les boucles annexes recherchant les fins de ligne s'arrêtent toujours également, puisque le fichier commence par '\n', se finit par '\n', et qu'à la fin de chaque ligne on a '\n' aussi. Si tu pouvais m'en dire plus, ce serait chouette!

Il est aussi possible que ce soit le résultat du jardinage mémoire ou que la boucle se situe ailleurs.

Au passage, ce choix d'arrêter au bout de 25 itérations est surprenant. Le nombre est peut être dimensionner correctement pour le fichier que tu utilises, mais ce n'est pas très réutilisable. Pourquoi ne pas arrêter lorsqu'on a parcouru tout l'espace disponible ?

Quant à position_current négatif et jardinage en mémoire, je pense que je sais d'où ça vient. Sous linux, quand fseek() a une valeur négative, il "ricoche" du début de fichier et se retrouve donc dans les valeurs positives. Puisque ça servait plus ou moins ma cause, je n'y avais pas touché, mais du coup j'ai modifié un peu la gestion des cas où position_current dépasse les limites du fichier en bas ou en haut.

Indépendamment de la vérification de la validité du déplacement, ce qui me surprends surtout, c'est que l'on puisse obtenir un offset en dehors du fichier.

Et si tu peux m'en dire plus concernant le comportement de fseek() sous windows, j'en serai ravi =)

Le souci, c'est que le comportement de fseek() comme tu l'utilises est indéfini, l'implémentation est en droit de faire ce qu'elle veut.
Je ne connais pas en détail le comportement de l'implémentation que j'utilise dans ce cas précis.

Toutefois, une des principales différence entre Windows et Linux sur les fichiers ouverts en mode texte concerne le codage de la fin de ligne.
Un seul caractère <LF> pour Linux et les deux caractères <CR><LF> sous Windows.
C'est géré lors de la lecture et de l'écriture par les fonctions adéquates qui masque le codage réel pour n'utiliser dans le code C uniquement \n.
Cependant, fseek() n'a pas l'obligation de traiter sous Windows les deux caractères comme n'en représentant qu'un.

Ce qui me fait penser, que j'ai oublié de convertir le fichier Linux d'exemple au format DOS, ce qui peut aussi poser des problèmes. Je vais le faire pour mes prochains tests.

Voilà donc la new version

J'essaierais d'y jeter un œil ce week-end.



[1] Pour la petite histoire, j'ai travaillé il y a quelques années sur un système (interne à l'entreprise) où le fseek() (enfin un équivalent) consistait en fait à lire le fichier depuis le début jusqu'à atteindre la position recherché. Dans ce cas, une lecture séquentielle était beaucoup plus rapide qu'une recherche dichotomique.

[gl]

La dernière version ne compile pas :

C:\Data\test_DVP\C\main.c||In function `main'
C:\Data\test_DVP\C\main.c|317|error: `LINK' undeclared (first use in this function)|
C:\Data\test_DVP\C\main.c|317|error: (Each undeclared identifier is reported only once|
C:\Data\test_DVP\C\main.c|317|error: for each function it appears in.)|
C:\Data\test_DVP\C\main.c|329|error: passing arg 6 of `chercheAmbiguite' from incompatible pointer type|
C:\Data\test_DVP\C\main.c|329|error: too many arguments to function `chercheAmbiguite'|
C:\Data\test_DVP\C\main.c|331|error: passing arg 6 of `chercheAmbiguite' from incompatible pointer type|
C:\Data\test_DVP\C\main.c|331|error: too many arguments to function `chercheAmbiguite'|
||=== Build finished: 7 errors, 0 warnings ===|

[mikhailo]

Re,

Sorry pour le lagtime ainsi que pour ce 'LINK' non déclaré; juste une erreur de "frappe". Pour le régler, il faut juste rajouter un #define LINK "link_words.txt" au début, le fichier "link_words.txt" construit sur le même modèle que le fichier dico, mais contenant les mots du type "de", "avec", etc.:

comme 120 prep [pred='comme_____1<obj:sn|sa>',@pcascomme]
confer 120 prep [pred='cf_____1<obj:sn|sa>']
contre 120 prep [pred='contre_____1<obj:sn|sa|sinf>',@pcascontre]
dans 120 prep [pred='dans_____1<obj:sn|sa>',@pcasdans]
de det [det=+,define=-,@p]
de 120 prep [pred='de_____1<obj:sn|sa|scompl|sinf>',@pcasde]
depuis 120 prep [pred='depuis_____1<obj:sn|sa>']
derriere 120 prep [pred='derriere_____1<obj:sn|sa>']
des det [det=+,define=-,@p]
des 120 prep [pred='des_____1<obj:sn|sa>']
dessous 120 prep [pred='dessous_____1<obj:sn|sa>']
dessus 120 prep [pred='dessus_____1<obj:sn|sa>']
devant 120 prep [pred='devant_____1<obj:sn|sa>',@pcasdevant]
devers 120 prep [pred='devers_____1<obj:sn|sa>']
dixit 120 prep [pred='dixit_____1<obj:sn|sa>']
donc coo [pred='donc_____1<arg1,arg2>',cat = coo]
donc csu []
du det [det=+,define=-,@ms]

en fait, j'étais en voyage pendant une dizaine de jours, et j'ai eu une idée rigolote: tu me disais que c'est l'accès en mémoire qui prend du temps car les têtes de lecture doivent se déplacer de fichier en fichier, dès lors que l'on en utilise plus d'un seul; et du coup, si je transforme le fichier texte en tableau de chaines de caractères (char **), et si je fais toutes mes opérations dessus, ce serait probablement plus rapide et peut-être même plus simple, puisque tous les détails avec fseek() disparaissent.

En revanche, ça va bouffer de la ram... Est-ce que, du coup, ce serait déontologiquement acceptable de faire ça ainsi?


PS: est-ce qu'un modérateur pourrait please changer le titre du topic en "ouvrir un fichier en global // optimisation du temps d'exécution" ? Merci d'avance =)