Discussion :

[Rodrigue]

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]

Salut,

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

Fredy

[Luc Hermitte]

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

[Jean-Marc.Bourguet]

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]

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]

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]

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]

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]

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