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

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?

Salut,

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

Fredy

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

Citation:

---

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)

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, ...

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.

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

Citation:

---

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:

---

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:

---

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 :aie:

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

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 :scarymov:

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 ;):P)

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] :P
• 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 :question:)... Mais une simple "observation" de différents codes sources devrait te permettre d'y arriver ;)

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.

Citation:

---

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

---

C'est le but du projet clang.

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 :D

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:

---

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

---

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

Citation:

---

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 :(

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 !

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 :yaisse2: (on s'occupe comme on peut :aie:)

Salut,

Citation:

---

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:

---

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.