Analyser du code C/C++: détecter les struct, class et fonctions

**Rodrigue** · 19/09/2007, 20h41

Bonjour,

Je souhaiterais analyser du code C/C++. Dans un premier temps, je souhaiterais détecter toutes les fonctions déclarées dans plusieurs fichiers ainsi que les classes et les structures. Connaissez-vous un projet équivalent assez simple à comprendre en open-source (ex.: doxygen)?

Comment vous y prendriez-vous?

**Fredy Kruger** · 19/09/2007, 22h37

Salut,

ca depond de system, essaye BoUML, StarUML ou Umbrella.

Fredy

**Luc Hermitte** · 19/09/2007, 23h57

Qu'entends-tu par "analyser" ?
Je partirai sur ctags personnellement.

**Jean-Marc.Bourguet** · 20/09/2007, 09h09

Envoyé par Luc Hermitte

Qu'entends-tu par "analyser" ?
Je partirai sur ctags personnellement.

Ou cscope.

Je ne connais pas de front-end C++ facilement utilisable (ca ferait d'ailleurs un beau projet)

**Aurelien.Regat-Barrel** · 20/09/2007, 10h11

Note qu'a cause du préprocesseur, un bete analyse du code peut passer a coté de déclarations si le code utilise des macros etc...
On trouve des exemples de code intéressants dans les exemples de boost : un préprocesseur complet, un "extracteur" de déclarations de classes, ...

**zais_ethael** · 20/09/2007, 13h03

Je crois savoir que Eclipe CDT et Code::Blocks utilisent tout deux ctags pour implémenter leur auto-completion, ça fait déja un point de départ.

**Rodrigue** · 20/09/2007, 17h58

Merci pour vos réponses, je vais regarder ces différents projets

Qu'entends-tu par "analyser" ?

Je voudrais parser du code C ou C++ sous la forme d'un fichier XML dans un "pseudo-langage" (les imbriquements représenteraient une structure de type arbre).

Un code de ce type:

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
 
int Add(int A, int B); //déclaration de fonction
 
int g1=0, g2; /*variable globale
avec un commentaire sur plusieurs lignes */
 
struct test {
float a;
double b;
std::string c;
};
 
/**
 * Fonction principale
 **/
 
int main(int argc, char* argv[])
{
   int i, j;
   test k;
   bool isOk = true;
 
   k.a = 3.14;
 
   //...
 
   if(isOk)
   {
        //...
   } else {
       //...
   }   
}
 
int Add(int A, int B)
{
   return A + B;
}

devrait devenir (dans ce genre là, je l'ai fait vite fait

):

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
<FUNCTION_DECL>
   <NAME>Add</NAME>
   <RETURN_TYPE>int</RETURN_TYPE>
   <PARAMS>
      <P1>
      	<NAME>A</NAME>
      	<TYPE>int</TYPE>
      </P1>
      <P2>
      	<NAME>B</NAME>
      	<TYPE>int</TYPE>
      </P2>
   </PARAMS>
</FUNCTION_DECL>
 
<GLOBAL_VAR>
int g1=0, g2; /*variable globale
avec un commentaire sur plusieurs lignes */
</GLOBAL_VAR>
 
<STRUCTURE>
struct test {
float a;
double b;
std::string c;
};
</STRUCTURE>
 
/**
 * Fonction principale
 **/
 
 <FUNCTION>
int main(int argc, char* argv[])
{
   int i, j;
   test k;
   bool isOk = true;
 
   k.a = 3.14;
 
   //...
 
   if(isOk)
   {
        //...
   } else {
       //...
   }   
}
</FUNCTION>
 
<FUNCTION>
int Add(int A, int B)
{
   return A + B;
}
</FUNCTION>

Remarquez que j'ai fort détaillé le premier bloc. Dans un premier, je me contenterais très bien de récupérer la structure globale d'un fichier source

Merci beaucoup pour votre aide! J'espère que vous voyez mieux ce que je souhaite réaliser... si vous avez des questions, n'hésitez surtout pas à me les poser

**zais_ethael** · 20/09/2007, 20h57

Je sans que Doxygen (ou un module) est capable de générer du xml, ce serait peut-être une piste à explorer.
En tous cas je ne peux que te conseiller de réutiliser l'un des (rares) programmes qui sont capables de te macher le travail, faire son propre compilo C++ relève de la démence

**koala01** · 21/09/2007, 03h57

Salut,

Si tu veux vraiment tout faire à la main, il faut que tu réfléchisse à ce qui peut se trouver, et dans quel ordre, dans un fichier de code source (dans le fichier d'en-tête, d'abord, puis dans le fichier d'implémentation

)

Ainsi, tu te rendra compte que tu peux trouver:

Des commandes préprocesseurs (lignes commençant par #
des commentaire, uni et multi lignes (commençant par // ou commencant par /* et terminant par */
des mots clés (class, struct, friend)
des indicateurs sur l'accessibilité des éléments (private, protected, public)
des blocs (commencant par { et terminant par })
des listes d'arguments (commencant par ( et terminant par ) )
des tailles de tableau (commencant par [ et terminant par ] )
des spécificateurs de classe de stockage (extern, static, register,...)
des qualificateurs constant/volatile (const et volatile)
une représentation de l'utilisation de mémoire (référence, pointeur, pointeur de pointeur)
des "fins d'instructions" (";")
des identifiants
...

Tu remarquera que les mots clés ont une signification précise et que tous ces éléments se trouvent généralement dans un ordre précis, mais que certains sont incompatible entre eux:

tu ne peux pas déclarer une variable sous la forme de Type& Mavar[10]
Une déclaration de variable prend une synthaxe du genre de <S C Spec> <C V Qual> Type<utilisation memoire> nom <taille>
une déclaration de fonction prend une synthaxe du genre de <inline><S C Spec | virtualite> <C V Qual> Type_de_retour<utilisation mémoire> Nom(<liste d'arguments>)<throw(<liste d'erreur>)> <C V Qual>;
une déclaration de classe prend la forme de class NomDeClass <: <visibilité> classe mere> <, <visibilité> classe_mere> (plusieurs fois possible) >{
Un indicateur de visibilité s'applique jusqu'à ce qu'un autre indicateur soit placé
tous les élément "facultatifs" ont une valeur par défaut, qui peut varier en fonction des circonstances (par exemple: la visibilité par défaut d'une structure est publique, alors qu'elle est privée pour les classes)
...

Ce ne sont, bien sur, que quelques exemples des choses auxquelles tu dois être attentif

A partir de là tu pourras commencer à te dire que ton fichier, ce n'est qu'un arbre N-aire, dont la racine est... le fichier.

La racine peut contenir une collection d'objets parmis

un instruction preprocesseurs
une déclaration de variables (libre)
une déclaration de fonctions (libre)
une espace de nommage
une (pré)déclaration de classe ou de structure

Un espace de nomage peut contenir une collection d'objets exactement identique à celle qui peut etre contenue par la racine.

une déclaration de classe peut contenir

une collection d'héritage
une collection d'objet parmis
- une visibilité (private, protected, public)
- une instruction pré processeur

une signification de visibilité peut contenir une collection d'objets parmis

une déclaration de classe ou de structure
une déclaration ou une définition de fonction
une instruction preprocesseur
une déclaration d'amitie
une déclaration de variable

Enfin, il y a les feuilles et les autres noeuds:

Une fonction peut être une feuille (si ce n'est que la déclaration) ou un noeud (si c'est aussi la définition)
une déclaration d'amitié est une feuille
une déclaration de variable est une feuille

Une fois que tu auras tout cela, tu disposera de l'ensemble de ce qui t'es nécessaire pour créer ton fichier XML...

Aucune liste n'est exhaustive, certaines choses manquent et c'est à toi de les trouver (où serait le plaisir, sinon

)... Mais une simple "observation" de différents codes sources devrait te permettre d'y arriver

**Aurelien.Regat-Barrel** · 21/09/2007, 08h47

Il y a GCC XML mais le projet n'avance plus et est basé sur GCC 3.x. C'est pas du bete parsing, c'est une réelle compilation du programme, avec inclusion des en-tetes etc... Le code doit etre compilable avec GCC. En fait, au lieu de te sortir un code objet, il te sort un XML (tres verbeux). C'est pas super utilisable en fait, mais rien ne t'échappe.

**loufoque** · 21/09/2007, 10h52

Je ne connais pas de front-end C++ facilement utilisable (ca ferait d'ailleurs un beau projet)

C'est le but du projet clang.

**Rodrigue** · 21/09/2007, 23h04

Merci beaucoup pour vos réponses! Je vois que le sujet est intéressant...

Je précise que je ne souhaite pas détecter d'erreur dans le code... mais seulement repérer des patterns bien déterminés

Pour ce faire, j'utilise boost::regex. J'ai déjà récupéré l'exemple qui permet de détecter les classes dans un fichier (le pattern ne fonctionne pas lorsqu'on met un commentaire entre le nom de la classe est l'accolade): class NOM /* comment */ {.
J'ai également écrit une petite expression régulière pour détecter les directives préprocesseurs...

J'essaye maintenant de détecter les commentaires multilignes (c'est pas gagné). J'ai essayé avec ce pattern mais ça ne fonctionne pas:

Code :

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

"//\*(([[:punct:]]|[[:alnum:]]|[[:blank:]])*)\*//"

J'ai du mal avec le dédoublement des caractères ...

**Matthieu Brucher** · 21/09/2007, 23h32

Envoyé par Aurelien.Regat-Barrel

Il y a GCC XML mais le projet n'avance plus et est basé sur GCC 3.x. C'est pas du bete parsing, c'est une réelle compilation du programme, avec inclusion des en-tetes etc... Le code doit etre compilable avec GCC. En fait, au lieu de te sortir un code objet, il te sort un XML (tres verbeux). C'est pas super utilisable en fait, mais rien ne t'échappe.

GCC XML est utilisé par exemple pour Cable-SWIG, Boost.Python, et sans doute d'autres pour la génération automatique de code/wrappers.
Apparemment, il avancerai un peu régulièrement (je vois des mails dans ce sens sur c++-sig), mais comme tu le sous-entend aussi, on n'en entend pas trop parler

**lun4t1k** · 21/09/2007, 23h41

Bonjour, ce post me rappelle un cas auquel j'ai du faire face récemment.
Je devais parser des headers a la recherche d'enums pour en récupérer chaque item.
Et je me suis vite aperçu que les syntaxes pouvaient être diverses.
J'ai arrangé tout ca a l'aide de regExp.
Donc attention aux commentaires vicieusement mals placés, aux multiples facettes de déclaration, instanciation que le c++ autorise!

Sinon j'ai utilisé Doxygen, et il permet un grand choix de fichiers de sortie.
A essayer absolument !

**Rodrigue** · 22/09/2007, 13h00

Merci pour vos réponses. Je vais ouvrir un autre post pour mes problèmes d'expression régulière

lun4t1k>
Je connais déjà Doxygen

mais je souhaiterais trouver les structures moi-même

(on s'occupe comme on peut

)

**Mat007** · 22/09/2007, 15h28

Salut,

Envoyé par Rodrigue

(...)je souhaiterais trouver les structures moi-même

Si tu te limites à un sous ensemble des constructions valides du C++ c'est peut-être faisable au prix de pas mal de cheveux en moins (fais des tests unitaires au moins sinon c'est même pas la peine de te lancer là-dedans).
Mais par exemple en C++ on peut faire :

Code :

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

1
2
3
4
5
6
7
8
9
10
class C
{
  class D
  {
    void f()
    {
      class E {};
    }
  };
};

Et ce n'est qu'un exemple simple...
Il y a aussi le coup classique des déclarations de fonctions qui ressemblent en tous points à des initialisations de variables (et inversement), les méthodes qui sont dans deux classes de même nom mais dans des namespaces différents qu'il faut différencier, etc..

Enfin j'imagine que ça dépend du but final.
Dans tous les cas : bon courage !

MAT.

Analyser du code C/C++: détecter les struct, class et fonctions

C++

Discussions similaires

Partager

Partager