Algorithme d'Extraction des noms de fonctions C en PERL

**gronaze** · 23/06/2010, 15h28

Bonjour,

Je me lance en perl pour extraire de fichiers C les noms des fonctions déclarées... eh oui c'est une vaste entreprise !

Voici comment je souhaite procéder, une fonction en C est définit de la manière suivante :

Code :

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

1
2
3
4
Portée type nom_fonction ( type_arg arg1, type_arg arg2, /* comment */, type_arg arg3 ... )
{
plein de choses
}

je vais donc tenter de faire une recherche sur les token (disons que dans un premier temps je ne gère pas les commentaires):
Portée = { PRIVATE, extern, vide, ...}
type = { int, double int, void, ... }
type_arg = type

plusieurs questions me viennent à l'esprit :
1) Pensez-vous que ma démarche est correcte ?
2) Est-ce qu'il existe déjà un moyen d'extraire les noms des fonctions d'un répertoire/fichier
3) Le perl est il adapté ?
4) Est ce que je vais galérer ?

Merci pour vos réponses.

**Philou67430** · 23/06/2010, 16h22

Le premier élément de réponse serait d'introduire une complexité supplémentaire dans le sens ou un type de retour peut être un type construit, voire une constante de préprocesseur, étendant ainsi la liste des tokens pour cet élément sémantique.
Je dirais donc que si tu fais du 100% perl et que tu souhaites être exhaustif, tu devrais galérer (puisqu'il faudrait presque réaliser un parser C complet).

Pour éliminer le problème des constantes de préprocesseur, il est possible de préprocesser le source C avec gcc -E pour obtenir le source C brut.
Pour l'analyse ultérieure, et si tu voulais te limiter aux types de base pour les retours de fonction, l'analyse est du domaine du possible, même si elle n'est pas triviale.

**Philou67430** · 23/06/2010, 16h26

Je n'ai pas regardé le détail, mais ce module pourrait t'être utile : C::Scan

Et pour écrire un parser, Parse::Yapp

**gronaze** · 23/06/2010, 18h04

Merci Philou67430 de me répondre,

Mon objectif est de me simplifier la tache : lancer un script et attendre le résultat, c'est pourquoi j'oublie tout de suite le gcc -E (en plus du makefile, il faudrait que je mette un paquet d'option de compilation...)

Le module C::scan m'a l'air d'être pas mal, je regarde ça tout de suite.

**gronaze** · 28/06/2010, 10h55

Beh finalement le PERL c'est pas si difficile, j'ai réussi à faire un petit script qui extrait les prototypes des fonctions sans utiliser les modules proposés par philou...
Il marche pas trop mal mise à part quelques faux-positifs, en tout cas c'est suffisant pour ce que je veux faire.

Si quelqu'un veut l'améliorer, voici le code :

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
 
#!/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");

**Philou67430** · 28/06/2010, 13h53

Bravo

Finalement, tu n'es pas un gronaze en perl

Algorithme d'Extraction des noms de fonctions C en PERL

Langage Perl

Discussions similaires

Partager

Partager