Discussion :

[jo_pich]

Bonjour à tous,

Connaissez vous un outils qui pourrait lister les variables utilisées dans un code source en C ?

Je m'explique, j'ai un code source qui déclare genre 40000 variables mais qui ne les utilise pas toutes (ou plus toutes, c'est historique)
Je cherche un moyen de savoir celles qui sont vraiment utilisées et celles qui ne le sont plus (pour info, c'est environ moitié moitié)

Ca existe forcement : un bon parser sait faire ça, voire un compilo avec des options d'analyse ou de reporting sur le code.

Mais impossible de trouver. Si vous avez des idées .....

Sinon, restera plus qu'à essayer de développer mon propre outil ... Marrant mais sans doute un peu galère.

Merci d'avance pour votre aide,

Pich

[ram-0000]

La pluspart des compilateurs maintenant savent dire quelle sont les variables non utilisées ou utilisées avant d'être initialisées.

Il suffit de monter le niveau de verbosité lors de la compilation.

Quel compilateur et quelles options de compilation utilises-tu ?

[jo_pich]

Merci pour cette réponse (rapide qui plus est).
Donc je suis sous visual 6 (oui, je sais c'est vieux) et mes niveau de warning sont plutôt bas.
Mais dans tous les cas, je ne suis pas sur que cela puisse m'aider.

En fait le problème que j'ai est plus compliqué que ce que j'ai décrit. j'avais essayé de simplifier mais je crois que je suis bon pour rentrer un peu plus dans le detail.

Bref,
Mon soft déclare environ 40 000 variables dans une dll dédiée à cela (appelée Commons.dll).
Les variables sont en fait des membres de structures déclarées comme suit :

_declspec(dllexport) struct // Export
{
int iVariable1;
int iVariable2;
// ...
} STRUCT1;
// On definit ensuite une macro
#define VARIABLE1 STRUCT1.iVariable1

J'ai comme cela environ 500 fichier définissant ces structures.

Mes autres dll accèdent à ces variables en déclarant les structures comme

_declspec(dllimport) struct // Import
{
int iVariable1;
int iVariable2;
// ...
} STRUCT1;

puis en utilisant directement la macro
VARIABLE1.
Exemple :
VARIABLE1 = 1;

Enfin, le linker link avec la dll commons

Ca marche très bien et est adapté à l'utilisation que nous en faisons.

Maintenant, je dois construire un ICD (Interface Conception Document) de chacun de mes modules (mes autres dll)
=> liste détaillées des variables utilisées en entrée et en sortie par chaque dll.

Première étape, construire la liste des variables utilisées (savoir lesquelles sont en entrée et lesquelles sont en sortie sera facile).
D'où ma question :-). (si j'ai la liste complète de toutes les variables, je saurai faire le tri entre les externes et les internes)

Pour info, j'ai bien-sur essayé de générer le mapfile lors de la compil.
Malheureusement, le mapfile me donne la liste des structures utilisées (STRUCT1) mais pas du tout la liste des membres de cette structure.
Hors c'est bien cette liste de membre dont j'ai besoin.

Un compilo ou un bon parser connaitra forcement cette liste.
Mais je ne pense pas que les options de verbose m'aide bcp.

qu'en penses tu ?

Merci encore

Pich

EDIT : J'ai visiblement confondu ce qu'etait l'option Verbose.
Donc, si, peut etre que ça peut m'aider vu que je vois pas ce que c'est
Pour info, si besoin, je peux compiler sous Visual Studio 2005

[ram-0000]

Une méthode un peu bourin alors, tu renommes tous tes membres de structures de ta DLL Commons.dll sans modifier les macros et tu recompiles/link.

tu verras bien où cela crie (c'est que c'est utilisé) et tu remets les anciens noms pour ces membres là uniquement.

A mon avis, cela sera aussi rapide et efficace que trouver un parser et analyser les résultats.

[jo_pich]

J'y avais bien pensé mais faire ça pour 40 000 variables, je vais y passer ma vie ...
=> Renommer les 40000
Pour tous mes modules

=> Compiler module
Tant que erreur de compile

remettre le nom correcte de la variable
noter ce nom dans une liste annexe
recompiler module

fin tant que

fin pour

j'ai peur ;-)

[matafan]

D'un autre côté quelque chose me dit que tu n'as pas vraiment 40000 variables.

[jo_pich]

La pluspart des compilateurs maintenant savent dire quelle sont les variables non utilisées ou utilisées avant d'être initialisées.

Il suffit de monter le niveau de verbosité lors de la compilation.

Quel compilateur et quelles options de compilation utilises-tu ?

En fait, ta première idée pourrait qd même m'interesser.

Visiblement, Visual n'a d'option verbose que pour le link.
J'ai regardé GCC mais ce que l'option verbose ressort lors de la compile ne semble pas etre ça.

Tu connais un compilo qui a une option verbose permettant de lister les variables utilisées ?

[ram-0000]

Visiblement, Visual n'a d'option verbose que pour le link.

Je ne me rappelle plus très bien de Visual 6.0 (c'était il y a longtemps) mais il me semble bien qu'il y avait des options de compilation qui était relativement strictes. Par contre, le danger est de trouver d'autres warning et erreurs dans ton code (est-ce que c'est vraiment un danger d'ailleurs ?).

[jo_pich]

Je ne me rappelle plus très bien de Visual 6.0 (c'était il y a longtemps) mais il me semble bien qu'il y avait des options de compilation qui était relativement strictes. Par contre, le danger est de trouver d'autres warning et erreurs dans ton code (est-ce que c'est vraiment un danger d'ailleurs ?).

Non, pas de problèmes pour de nouveau warning .
Par contre, que ce soit visual 6 ou 2010, je n'ai trouvé d'option verbose que pour le link

[6-MarViN]

Pour gcc y'a une option (-0 ou -pipe) qui te dit si les variables sont utilisées ou pas.