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
|
/*
* Exemple Recherche de données. Bêta 0.1
* File: source.c
* Version: 0.0.1 GPL V3.
* Created by SAMBIA39 on 28/12/2015.
* Copyright (c) 2015 SAMBIA39 & Developpez.net & Xjagercodes.com
*/
#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
/*
* Structure des donnée
* et gestion des collisions.
*/
struct s_data{
char *pData;
struct s_data *ptr;
};
/*
* Pointeur sur tableaux de char
* pour les résultats d'inconnue.
*/
typedef char *pTabRslt[UCHAR_MAX];
/*
* Pointeur sur tableaux de structure
* par définition la table de hachage.
*/
typedef struct s_data *pData[USHRT_MAX];
/*
* Fonction qui fournit l'id de stockage
* des informations grâce à la signature
* du texte.
*/
unsigned short f_id_data( char *src ){
unsigned int id = 0;
if( NULL != src ){
while( '\0' != *src )
id = ( id * 31 + (unsigned char)*src++ )%USHRT_MAX;
}
return id;
}
/*
* Fonction qui ajoute les éléments
* à leurs indices fournis adéquats.
*/
void f_add_data( pData data, char *str ){
unsigned short id = 0;
struct s_data *ptr = NULL;
id = f_id_data( str );
if( NULL == (ptr = malloc( sizeof(struct s_data)))){
fprintf( stderr, "(%d)\t%s\n\t:%s\n", errno,
"Échec allocation de mémoire", strerror(errno) );
exit( EXIT_FAILURE );
}
ptr->pData = strdup( str );
ptr->ptr = data[id];
data[id] = ptr;
}
/*
* Fonction qui teste l'existence de la
* donnée en comparant les indices si l'indice
* pointe sur une cellule vide alors on a une
* valeur non répertoriée dans le cas contraire,
* elle existe déjà.
*/
int f_ExistData( pData data, char *cmp ){
struct s_data *ptr = NULL;
unsigned int id = f_id_data( cmp );
ptr = data[id];
for( ptr = data[id]; NULL != ptr; ptr = ptr->ptr ){
if( 0 == strcmp( ptr->pData, cmp) )
return 0;
}
return 1;
}
/*
* Fonction qui charge les éléments
* d'un fichier dans la bonne case
* de la table de hachage.
*/
void f_open_and_load_data(pData data, char *psrc ){
errno = 0;
FILE *pFile = NULL;
char buffer[UCHAR_MAX];
if( NULL == (pFile = fopen( psrc, "r") ) ){
fprintf( stderr, "(%d)\t:%s\n\t:%s\n", errno,
"Erreur open file", strerror(errno) );
exit( EXIT_FAILURE );
}
while( NULL != fgets( buffer, UCHAR_MAX, pFile) )
f_add_data( data, buffer );
fclose( pFile );
pFile = NULL;
}
/*
* Fonction qui affichage les
* informations stockées ( Les résultat ).
*/
void f_print_data( pTabRslt Data ){
unsigned int i = 0;
for( i = 0; NULL != Data[i]; i++ )
fprintf( stdout, "(%d) -> %s\n", i, Data[i] );
}
/*
* Fonction libération des
* mémoires allouées.
*/
void f_free_all_data( pTabRslt Data ){
unsigned int i = 0;
for( i = 0; i < UCHAR_MAX; i++ ){
if( NULL != Data[i] ){
free( Data[i] );
Data[i] = NULL;
}
}
}
/*
* Fonction qui charge sauvegarde
* les résultats dans un tableau en utilisant
* ou définissant un indice au cas où l'en
* souhaiteraient ajouter plus de résultats aux tableaux.
*/
int f_add_rslt( pTabRslt data, char *buffer, unsigned int offset ){
if( NULL == (data[offset] = malloc( strlen(buffer)+1 * sizeof(char)))){
f_free_all_data( data );
fprintf( stderr, "(%d)\t:%s[%d]\n\t:%s\n", errno,
"Erreur Allocation mémoire", offset, strerror(errno) );
return EXIT_FAILURE;
}
data[offset] = strdup( buffer );
return EXIT_SUCCESS;
}
/*
* Fonction qui compare le contenu
* d'un autre fichier avec la table de hachage.
*/
void f_cmp_info_data( pData data, pTabRslt Data_Rslt, char *src ){
errno = 0;
FILE *pFile = NULL;
char buffer[UCHAR_MAX];
unsigned int offset = 0;
if( NULL == (pFile = fopen( src, "r") ) ){
fprintf( stderr, "(%d)\t:%s\n\t:%s\n", errno,
"Erreur open file", strerror(errno) );
exit( EXIT_FAILURE );
}
while( NULL != fgets( buffer, UCHAR_MAX, pFile) ){
if( 0 != f_ExistData( data, buffer) ){
if( EXIT_FAILURE == f_add_rslt( Data_Rslt, buffer, offset ) )
exit( EXIT_FAILURE );
offset++;
memset( buffer, 0, UCHAR_MAX );
}
}
fclose( pFile );
pFile = NULL;
}
/*
* Fonction debug affichage
* des données du tableau de hachage.
*/
void f_print_data_hash( pData data ){
unsigned int i = 0;
struct s_data *p = NULL;
while( USHRT_MAX > i ){
for( p = data[i]; NULL != p; p = p->ptr ){
if( NULL == p->pData )
fprintf( stdout, "NULL\n" );
fprintf( stdout, "%s\n", p->pData );
}
i++;
}
}
/*
* Fonction debug free
* des données du tableau de hachage.
*/
void f_free_data_hsh( pData data ){
// À vous de faire quelque chose.
}
int main( void ){
//Déclaration et initialisation.
pData Data = { NULL };
pTabRslt Data_Rslt = { NULL };
//Chargement et comparaison des données.
f_open_and_load_data( Data, "Text_B.txt" );
f_cmp_info_data( Data, Data_Rslt, "Text_A.txt" );
//Affichage du résultat.
fprintf( stdout, "Résultat du traitement....\n" );
f_print_data( Data_Rslt );
f_free_all_data( Data_Rslt );
/*
* /!\ Obligation libération des données
* de hachage avant de quitter.
*/
return EXIT_SUCCESS;
} |
