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
|
#!/usr/bin/perl -w
# Ce script permet de donner tous les noms de fonctions trouvees dans
# les fichiers *.[sc] qui se trouve a partir du répertoire donne en entree
# Pour detecter une fonction il recherche la succesion de token :
# 1) Visibilite dee la fonction : PUBLIC / PRIVATE / Extern / none
# 2) Type retourne de la fonction : void / int / autres
# 3) Nom de la fonction
# 4) Du texte entre parentheses, voici les token interdit entre
# les parentheses : ;{}
# 5) Du texte entre accolades {}
# Usage du script : find_function.pl REPERTOIRE
# Le resultat est ecrit dans un fichier funtion_"REPERTOIRE".out.txt
#######################################################
# Fonctions utilisee dans le script #
#######################################################
#======================================================
# Nombre d'arguments : 1
# Argument(s) : un répertoire ($repertoire)
# Retourne : Tableau de fichier (@fichiers)
#======================================================
sub ListersFichiers {
my ( $repertoire ) = @_;
my @fichiers;
# Ouverture d'un répertoire
opendir (my $FhRep, $repertoire)
or die "impossible d'ouvrir le répertoire $repertoire\n";
# Liste fichiers et répertoire sauf (. et ..)
my @Contenu = grep { !/^\.\.?$/ } readdir($FhRep);
# Fermeture du répertoire
closedir ($FhRep);
# On récupère tous les fichiers
foreach my $nom ( @Contenu ) {
# Fichiers
if ( -f "$repertoire/$nom") {
push ( @fichiers, "$repertoire/$nom" );
}
# Repertoires
elsif ( -d "$repertoire/$nom") {
# recursivité
push ( @fichiers, ListersFichiers("$repertoire/$nom") );
}
}
return @fichiers;
}
#======================================================
# Nombre d'arguments : 1
# Argument(s) : Le nom du fichier ($fic_in)
# Retourne : Liste de nom de fonction (@nom_fonction)
#======================================================
sub extraire_fonction {
my ( $fic ) = @_;
my @nom_fonction;
my @nom_fonction_temp;
my $nom_fonction_temp;
my $etape_1_success;
my $etape_2_success;
my $etape_3_success;
my $etape_4_success;
my $nb_parenthese = 0;
# Initialiser les variables
$etape_1_success = 0;
$etape_2_success = 0;
$etape_3_success = 0;
$etape_4_success = 0;
# Ouvrir le fichier
if ( ( -e $fic ) and ( -r $fic ) )
{
# si le fichier existe en lecture, l'ouvrir
open (FIC, '<', $fic);
#print("$fic_read\n");
}
my $ligne; # liste des elements de la ligne
my @lig; # tableau contenant les elements de la liste
my $is_word;
my @list_arg_fonction = ('void', 'Byte', 'byte', 'boolean', 'word32', 'word');
my $parenthese_ouverte = 0;
my $parenthese_fermee = 0;
# Parser le fichier ligne par ligne
while ($ligne = <FIC>)
{
# ajouts d'espaces entre le cara "("
$ligne =~ s/\(/ \( /g;
# ajouts d'espaces entre le cara ")"
$ligne =~ s/\)/ \) /g;
# ajouts d'un espace avant le ";"
$ligne =~ s/\;/ \;/g;
# les espaces permettent de separer chaque mot
@lig = split(/ +/, "$ligne");
# Chercher chaque element de la ligne
foreach $champ (@lig)
{
# Recherche du type de retour de la fonction
if ( $champ =~ /\;/ )
{
# En cas de ";" il s'agit d'une instruction et pas d'une fonction
$etape_1_success = 0;
$etape_2_success = 0;
$etape_3_success = 0;
$etape_4_success = 0;
@nom_fonction_temp = ();
$parenthese_ouverte = 0;
$parenthese_fermee = 0;
}
# Etape 2 : reconnaitre le token du nom de la fonction
if ( ($etape_1_success == 1) and ($etape_2_success == 0) )
{
if ( ($champ =~ /\(/) )
{
# Parenthese ouverte trouvee
$parenthese_ouverte = $parenthese_ouverte + 1;
# ajout de la parenthese dans le tableau temporaire
push (@nom_fonction_temp, $champ);
}
if ( ($champ =~ /\)/) )
{
# Parenthese fermee trouvee
$parenthese_fermee = $parenthese_fermee + 1;
# ajout de la parenthese dans le tableau temporaire
push (@nom_fonction_temp, $champ);
}
# Si il y a d'abord une parenthese fermee ce n'est pas normal
if ( $parenthese_fermee > $parenthese_ouverte )
{
$etape_1_success = 0;
$etape_2_success = 0;
$etape_3_success = 0;
$etape_4_success = 0;
@nom_fonction_temp = ();
$parenthese_ouverte = 0;
$parenthese_fermee = 0;
}
# Toutes les parentheses vont par paire
elsif ( $parenthese_ouverte == $parenthese_fermee )
{
# Etape 2 : token du nom de fonction TROUVE
$etape_2_success = 1;
# Reinitialisation des parentheses
$parenthese_ouverte = 0;
$parenthese_fermee = 0;
# Ajout du nom de la fonction dans un tableau temporaire
push (@nom_fonction_temp, $champ);
}
}
# Etape 3 : reconnaitre le token de l'ouverture de parenthese
elsif ( ($etape_1_success == 1)
and ($etape_2_success == 1)
and ($etape_3_success == 0)
)
{
if ( $champ =~ m/\(/ )
{
# Etape 3 : token de parenthese ouverte
$etape_3_success = 1;
# Signaler qu'une parenthese est ouverte
$nb_parenthese = 1;
# Ajout de l'ouverture de parenthese dans un tableau temporaire
push (@nom_fonction_temp, $champ);
}
else
{
# Ajout des mots lus
# push (@nom_fonction_temp, $champ);
}
}
# Etape 4 : recuperer tous les arguments entre parentheses
elsif( ($etape_1_success == 1)
and ($etape_2_success == 1)
and ($etape_3_success == 1)
and ($etape_4_success != 1)
)
{
if ($champ =~ m/\(/ )
{
$nb_parenthese = $nb_parenthese + 1;
}
if ( ($champ =~ m/\)/) and ($nb_parenthese == 1) )
{
# Etape 4 : parenthese fermee
$etape_4_success = 1;
# Signaler que toutes ls parentheses sont fermees
$nb_parenthese = 0;
# Ajout de la fermeture de parenthese dans un tableau temporaire
push (@nom_fonction_temp, $champ);
}
else
{
if ( $champ =~ m/\)/ )
{
$nb_parenthese = $nb_parenthese - 1;
if ( $nb_parenthese < 1 )
{
$etape_1_success = 0;
$etape_2_success = 0;
$etape_3_success = 0;
}
}
# Ajout des mots lus
push (@nom_fonction_temp, $champ);
}
}
# Etape 5 : verifier qu'il y a une accolade ouverte
elsif( ($etape_1_success == 1)
and ($etape_2_success == 1)
and ($etape_3_success == 1)
and ($etape_4_success == 1)
)
{
if ( $champ =~ m/\{/ )
{
# Tous les token ont ete verifie, ecriture du nom de la fonction
# Ajout du nom de la fonction dans le tableau principal
$nom_fonction_temp = "@nom_fonction_temp\n\n";
push(@nom_fonction, $nom_fonction_temp);
}
}
foreach $list_arg_fonction (@list_arg_fonction)
{
# Etape 1 : reconnaitre le token du type de retour de la fonction
# if ( grep (/$list_arg_fonction/, $champ) and ($etape_1_success == 0) )
if ( ($champ =~ /$list_arg_fonction/i)
# and ( $list_arg_fonction =~ /$champ/i ) # comparaison de chaine commutative
and ($etape_1_success == 0)
)
{
# Etape 1 : token du type de retour de fonction TROUVE
$etape_1_success = 1;
# Initialisation du tableau temporaire
@nom_fonction_temp = ();
# Ajout du type dans un tableau temporaire
push (@nom_fonction_temp, $champ);
}
}
} # fin de la boucle sur chaque mot de la ligne
} # fin du while
# Fermer le fichier
close (FIC);
return @nom_fonction;
}
#######################################################
# Fin des fonctions utilisees dans le script #
#######################################################
use strict;
# Recherche dans les fichiers contenant l'estension suivante :
#my @ext_recherche = ('s', 'c', 'asm', 'h');
my @ext_recherche = ('c', 'asm');
print ("Debut du script\n");
print ("Nom du programme : $0\n");
if ( !defined( $ARGV[0] ) )
{
print ("Usage : $0 REPERTOIRE\n");
exit (-1);
}
# Initialisation du repertoire d'analyse
my $REP_ANALYSE = $ARGV[0];
# Verification de l'existence du repertoire
if ( -e $REP_ANALYSE )
{
if ( -d $REP_ANALYSE )
{
print("Le repertoire \"$REP_ANALYSE\" est en cours d'analyse\n");
}
else
{
print("\"$REP_ANALYSE\" est un fichier et pas un repertoire !\n");
exit(-1);
}
}
else
{
print ("Le repertoire \"$REP_ANALYSE\" n'existe pas\n");
exit (-1);
}
# Recherche des fichiers dont le nom fini par l'extension @ext_recherche
# Recuperer le nombre de fichier type de fichier a analyser
my $nb_type_fic = $#ext_recherche + 1;
# Rechercher la liste de tous les fichiers a partir du repertoire donne
my @Liste_Fichiers = ListersFichiers($REP_ANALYSE);
my $Lst_fic = "@Liste_Fichiers";
# Tableau contenant toutes les fonctions
my @tab_fonction = ();
# Parcours de chaque type de fichier
for ( my $type = 0; $type < $nb_type_fic; $type+=1 )
{
my $extension = "\\.$ext_recherche[$type]";
print ("$extension\n");
# Parcours de chaque fichier
my @list_c = grep (/$extension/, @Liste_Fichiers);
my $Liste_c = "@Liste_Fichiers";
my @prototype_fonction;
my $prototype_fonction;
foreach my $fic (@list_c)
{
# Ajout du nom du fichier traite
#push(@tab_fonction, $fic);
# Rechercher les fonctions
@prototype_fonction = extraire_fonction("$fic");
$prototype_fonction = "@prototype_fonction";
# Ajout du prototype de la fonction
push(@tab_fonction, $prototype_fonction);
}
}
# Liste contenant toutes les fonctions
my $list_all_function = "@tab_fonction";
# Faire un fichier de sortie
# creer le fichier
my $fic_out = "$REP_ANALYSE\\$0.out.txt";
print ("Le resultat se trouve dans le fichier $fic_out\n");
open (FIC_OUT, '>', $fic_out);
print (FIC_OUT "$list_all_function");
close(FIC_OUT);
# Fin du script
print("Le script \"$0\" s'est correctement execute\n"); |
