Parser de code pour un intellisense

**Amnell** · 18/09/2009, 00h24

Bonjour,

Dans le cadre d'un projet, je souhaite utiliser un outil qui parserait du code pour en faire un arbre exploitable pour réaliser un intellisense.
Si vous connaissez ce type d'outil et surtout comment le faire marcher, je vous prie de bien vouloir vous manifester !

Bonne soirée,
Amnell.

**Mac LAK** · 18/09/2009, 14h34

Pourquoi pas tout simplement Doxygen, en mode "EXTRACT_ALL" et sortie XML ?

**Amnell** · 19/09/2009, 00h09

Bonsoir,

Tout d'abord, merci de m'avoir répondu, c'est très gentil de votre part !
Concernant la solution que vous me proposez, je pense effectivement que cela pourrait être une bonne idée mais dans ce cas, je devrai passer par la console en appelant doxygen.exe(|| autre || rien >> Selon la plateforme).
N'étant pas du tout familiarisé avec ce programme, j'ai commencé par télécharger la documentation puis je m'y suis plongé, mais je me suis heurté à un problème : l'histoire des fichiers de configurations et des fichiers tags. Est-ce nécessaire de générer un fichier de configuration avant de faire un fichier de tags (à mon avis, l'idéal serait de ne pas passer par un fichier mais de tout simplement utiliser la sortie) ?
En terme de commande, je n'ai pas tout à fait saisi quelle syntaxe je devais adopter pour faire un EXTRACT_ALL et une sortie en XML. J'ai testé pas mal de choses mais je n'arrive pas encore à générer un fichier (ou alors il est généré je ne sais où).

Merci encore de votre aide !
Amnell.

**aoyou** · 19/09/2009, 12h32

Il y a le doxywizard pour simplifier la tâche de création du fichier de configuration. Quant aux fichiers de tag, ils n'ont un intérêt que quand tu veux faire des liens avec la documentation Doxygen d'autres modules.

**Amnell** · 19/09/2009, 13h41

Envoyé par aoyou

Il y a le doxywizard pour simplifier la tâche de création du fichier de configuration. Quant aux fichiers de tag, ils n'ont un intérêt que quand tu veux faire des liens avec la documentation Doxygen d'autres modules.

Justement, doxywizard ne me sert à rien car l'intellisense doit se mettre à jour tout seul, ce n'est pas à l'utilisateur de spécifier les préférences.

**aoyou** · 19/09/2009, 16h19

Le doxywizard te permet de préparer le fichier de configuration Doxyfile. Tu ne le fais qu'une fois. Je ne vois pas de problème, après tu pourras appeler Doxygen dessus.

Par contre, je crains que ton intellisense ne soit pas très rapide en passant par Doxygen. Enfin, ça dépend de ce que tu veux faire. Je connaissais une librairie qui parsait un code C++ en un flux XML mais je n'arrive plus à remettre la main dessus. Je cherche... mais de toutes façons le gain ne sera pas énorme.

Oui voilà c'est http://www.gccxml.org/HTML/Index.html. Le format XML généré correspond à la représentation interne de gcc. Tu pourrais comparer cette représentation XML avec celle de Doxygen. Attention, si je me rappelle bien, le parser C++ de Doxygen était dit incomplet, en particulier quant tu commencais à taper dans les templates.

**Amnell** · 19/09/2009, 18h23

Donc j'ai installé cela et j'ai lancé par la console le programme et voici le résultat, que je mette ou non l'option GCCXML_ROOT :

C:\Program Files\GCC_XML\bin>gccxml GCCXML_ROOT C:\Users\Amnell\Documents\My Test\main.cpp
Compiler "cl" is not supported by GCC_XML because none of MSVC 6, 7, or 7.1 is installed.
Could not determine GCCXML_FLAGS setting.

Tout de même, version 2004, ça fait vieux !

**aoyou** · 19/09/2009, 19h37

Bah, tu vois, je ne pensais même pas qu'il utilisait ou supportait Visual.

Désolé. Perso, j'utilise encore la 7.1, il y a trop de choses qui m'embêtent avec la version 8, je préférais avant)

Je viens de voire ceci...

GCCXML_COMPILER: The C++ compiler to be simulated. GCC-XML will attempt to automatically determine how to simulate the compiler specified by this setting. The compiler is specified by its executable name (such as "g++"). For Visual Studio, the compiler is specified by "msvc6", "msvc7", "msvc71", or "msvc8" (if "cl" is given, GCC-XML attempts to guess which VS to use).

Il semble supporter msvc8. D'autre part, je croyais qu'il simulait un compilateur. Donc, je ne vois pas pourquoi il cherche un compilo mais bon...

Tu as jeté un coup d'oeil aux différentes options ?

**Amnell** · 19/09/2009, 20h03

Envoyé par aoyou

Il semble supporter msvc8. D'autre part, je croyais qu'il simulait un compilateur. Donc, je ne vois pas pourquoi il cherche un compilo mais bon...

S'il a besoin d'un compilo, j'ai l'air idiot moi avec mon intellisense non portable ou limitée

Enfin, je pense que doxygen sera une solution plus à jour et plus pratique, mais je ne sais pas tellement m'en servir.
Comment créer un fichier de config et surtout comment le placer ?
Quelle est la commande pour parser un fichier source ?

Merci encore !

**aoyou** · 19/09/2009, 20h22

Oui effectivement, je pensais qu'il n'avait pas besoin de compilo. Dans ce cas-là, ca ne va pas te servir à grand chose.

Tu généres le Doxyfile avec le Doxywizard ensuite doxygen Doxyfile.

**Mac LAK** · 19/09/2009, 20h51

Le Doxyfile peut être généré à la main, automatiquement, "pipé" vers Doxygen.exe (tout comme la sortie de Doxygen, d'ailleurs), et le résultat récupéré directement. Tout peut se faire en ligne de commande, voire sans même l'affichage d'une console DOS.

Sinon, il y a aussi moyen d'ajouter un langage à Visual Studio, via un add-in, mais ça ne sera pas portable.

**Amnell** · 19/09/2009, 22h37

Envoyé par Mac LAK

Le Doxyfile peut être généré à la main, automatiquement, "pipé" vers Doxygen.exe (tout comme la sortie de Doxygen, d'ailleurs), et le résultat récupéré directement. Tout peut se faire en ligne de commande, voire sans même l'affichage d'une console DOS.

Je précise que c'est pour mon propre IDE que je souhaite faire cet intellisense.
Grâce à QProcess (car il est codé avec Qt), je peux appeler sans pour autant afficher une console, doxygen.exe. Ce qui me manque est en fait deux choses :
- La commande pour générer un fichier de configuration (pas moyen de comprendre la doc

)
- La commande pour l'exploiter et générer à la sortie de doxygen.exe le XML.

J'ai donc uniquement besoin d'un exemple tout bête d'une simulation d'une telle chose (génération des deux choses).

**Mac LAK** · 19/09/2009, 23h00

La doc est pourtant claire, tout comme l'aide en ligne... Tu peux générer un Doxyfile standard (options par défaut) via la commande "doxygen -s -g". Tu peux bien sûr en supprimer tous les commentaires, ou au contraire avoir un fichier "verbeux" en supprimant le "-s". Le fichier de configuration est simplement un fichier texte, contenant des lignes "clé = valeur".

A noter que, par défaut, il n'est PAS nécessaire de renseigner TOUTES les valeurs, mais uniquement celles qui diffèrent de la configuration par défaut de Doxygen ! Petit bémol, ces valeurs par défaut peuvent (parfois) changer lors d'une MAJ de Doxygen, mais cela reste rare.

Pour une sortie XML, le fichier va ressembler en gros à ça (je n'ai mis QUE les options propres à ton usage et à la sortie XML, le reste devra être configuré correctement) :

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
EXTRACT_ALL            = YES
EXTRACT_PRIVATE        = YES
EXTRACT_STATIC         = YES
GENERATE_TODOLIST      = NO
GENERATE_TESTLIST      = NO
GENERATE_BUGLIST       = NO
GENERATE_DEPRECATEDLIST= NO
SHOW_USED_FILES        = NO
SHOW_FILES             = NO
QUIET                  = YES
WARNINGS               = NO
INPUT                  =  (liste des fichiers à parser)
GENERATE_HTML          = NO
GENERATE_LATEX         = NO
GENERATE_XML           = YES
XML_SCHEMA             = (mettre ce qu'il faut)
XML_DTD                = (mettre ce qu'il faut)
INCLUDE_PATH           = (chemins d'include du projet)
PREDEFINED             = (les macros en cours du projet)
CLASS_DIAGRAMS         = NO
CLASS_GRAPH            = NO
COLLABORATION_GRAPH    = NO
GROUP_GRAPHS           = NO
INCLUDE_GRAPH          = NO
INCLUDED_BY_GRAPH      = NO

Il y a d'autres options à configurer (en testant, principalement), le but étant de ne pas laisser Doxygen générer des choses qui TE sont inutiles, mais qui restent coûteuses en temps. Là, je ne t'ai mis que les principales à modifier.

Pour l'appel, tu utilises la commande "doxygen -" (le "-" est important), et il prendra le Doxyfile sur l'entrée standard pour sortir un fichier XML à partir de la configuration fournie. Bien entendu, je te déconseille fortement de faire ça à la volée, mais plutôt de réserver cette génération lors de la compilation.

**Amnell** · 20/09/2009, 00h20

Merci beaucoup, c'était exactement la réponse que j'attendais !
En fait, je comptais passer par un thread qui travaillerait en permanence pour l'intellisense, plutôt que de m'occuper de cela lors de la compilation, de la manière suivante :

Code :

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

1
2
3
4
5
Si (la fenêtre est active && le projet a été modifié && si le thread est !enMarche)
{
	On lance de nouveau doxygen.exe;
	On traite le tout;
}

**koala01** · 20/09/2009, 01h08

Salut,

Je ne suis pas intimement persuadé que doxygen soit réellement ce qu'il te faut, ne serait-ce que parce que cet outil prend d'autant plus de temps à générer les différents fichiers que le projet devient important.

Une première approche "naïve" consisterait en fait à lire l'ensemble des fichiers de ton projet en recherchant les différents séparateurs possible, étant donné qu'ils sont clairement identifiés, et de placer chaque terme trouvé par ce biais dans une structure assurant l'unicité des valeur (un std::set

)

En y adaptant le principe du pattern composite, afin de permettre de représenter les membres et fonctions membres ou les arguments de fonctions dans la portée des classes et structures (ou énumération, espaces de noms, unions, ...) diverses tu devrais pouvoir arriver à quelque chose de sympa

Lorsque tu rencontre un séparateur, tu choisi selon le cas, le fait de remonter "à la racine" de ton arbre ou, au contraire, de chercher parmis les enfants pour permettre la sélection du terme suivant

Une autre approche sans doute beaucoup moins naïve et plus efficace serait à mon sens d'utiliser bison pour générer ton propre parseur

**Amnell** · 20/09/2009, 12h56

Bonjour,

Le principal problème est que je suis cent fois moins bon en C++ qu'avec Qt, ce qui ne va pas aider les choses.
Pour bison, j'ai vaguement compris que ce n'est pas pour Windows, ou du moins, il n'y a aucune mention disant de quelle manière procéder pour compiler pour Windows.

**koala01** · 20/09/2009, 15h02

Envoyé par zAmnellL

Bonjour,

Le principal problème est que je suis cent fois moins bon en C++ qu'avec Qt, ce qui ne va pas aider les choses.

Rien ne t'empêche de manipuler les chaines de caractères Qt au sein de ta structure

Cela pourrait te donner une arborescence proche de (très vite faite

)

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
class Symbol
{
    public:
        Symbol(QString const & n):parent_(0),name_(n){}
        Symbol(Symbol * p, QString const  & n):parent_(p),name_(n){}
        virtual ~Symbol(){}
        virtual void addChild(Symbol * toadd) = 0;
        Symbol* parent() {return parent_;}
        Symbol const * parent() const{return parent_;}
        QString const & name() const{return name_;}
        bool operator<(Symbol * s) const;
        {
            return name_<s->name();
        }
    private:
        Symbol * parent_;
        QString name_;
};
class SymbolHolder
{
    typedef std::set<Symbol*> set;
    typedef typename set::const_iterator const_iterator;
 
    public:
        SymbolHolder(){}
        const_iterator begin() const{return items_.begin();}
        const_iterator end() const{return items_.end();}
    protected:
        ~SymbolHolder()
        {
            for(iterator it=items_.begin();it!=items_.end();++it)
                delete (*it);
        }
        void add(Symbol * toadd)
        {
            items_.insert(toadd);
        }
    private:
        set items_;
};
class TerminalSymbol : public Symbol
{
    public:
        TerminalSymbol(Symbol* p, QString const & n):Symbol(p,n){}
        virtual ~TerminalSymbol(){}
        virtual void addChild(Symbol * toadd)
        {
            /* just does nothing */
        }
};
class NonTerminalSymbol : public Symbol,
                        public SymbolHolder
{
    public:
        virtual void addChild(Symbol * toadd)
        {
            add(toadd);
        }
};
bool beginsBy(Symbol* s, QString const &str)
{
    return s->name().substr(0,str.size())==str;
}
bool equal(Symbol* s, QString const & str)
{
    return s->name()==str;
}

Lorsque tu parse ton fichier, tu insères les symboles enfants avec addChild, et, lorsque tu veux afficher le choix, tu crée une liste (ou un tableau, ou tout type issu de Qt adapté)de chaines de caractères et tu sélectionne le symbol adéquat sous des formes proches de

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
void updateList(QStringList & sl, QString const & str, 
                NonTerminalSymbol * actual)
{
    sl.clear(); //vidons la liste de son contenu précédent
    for(NonTerminalSymbol::const_iterator it=actual->begin();
       it!=acutal->end();++it)
    {
        if( beginsBy((*it),str))
            sl.push_back((*it)->name());
    }
}
NonTerminalSymbol * selectIn(QString const & tofind,
                    NonTerminalSymbol * from)
{ 
    for(NonTerminalSymbol::const_iterator it=from->begin();
        it!=from->end();++it)
    {
        if(equal((*it),tofind))
            return (*it);
    }
    return 0;
}

(code écrit "à l'arrachée", non testé et contenant de ce fait surement quelques erreurs

)

Pour bison, j'ai vaguement compris que ce n'est pas pour Windows, ou du moins, il n'y a aucune mention disant de quelle manière procéder pour compiler pour Windows.

Tu as visiblement mal cherché: http://gnuwin32.sourceforge.net/packages/bison.htm

**Mac LAK** · 21/09/2009, 11h37

Envoyé par zAmnellL

En fait, je comptais passer par un thread qui travaillerait en permanence pour l'intellisense, plutôt que de m'occuper de cela lors de la compilation, de la manière suivante :

C'est vraiment pas ce que je te conseillerais : ça va vraiment plomber le système d'avoir un truc aussi "lourd" qui tourne aussi souvent...

Envoyé par koala01

Je ne suis pas intimement persuadé que doxygen soit réellement ce qu'il te faut, ne serait-ce que parce que cet outil prend d'autant plus de temps à générer les différents fichiers que le projet devient important.

Disons que c'est fonctionnel, ni plus, ni moins, et tu peux limiter très fortement la casse en parsant les fichiers un par un, au lieu de scanner le projet en entier : cela réduit les dépendances, donc réduction du temps de traitement. Et dans son cas précis, les dépendances ne sont justement pas nécessaires.
Mais ce n'est pas forcément une mauvaise idée en soi pour la faisabilité et/ou les essais primaires.

Envoyé par koala01

Une autre approche sans doute beaucoup moins naïve et plus efficace serait à mon sens d'utiliser bison pour générer ton propre parseur

C'est apparemment la méthode qu'utilise Visual Studio pour son propre Intellisense, en tout cas. Toutefois, cela peut être largement plus difficile à mettre en place que Doxygen, notamment vis-à-vis de la grammaire : si l'on ne sait pas ce qu'est une grammaire, difficile de trouver les erreurs qui pourraient s'être glissées dedans !

**koala01** · 21/09/2009, 13h50

Envoyé par Mac LAK

C'est vraiment pas ce que je te conseillerais : ça va vraiment plomber le système d'avoir un truc aussi "lourd" qui tourne aussi souvent...

+1...

Disons que c'est fonctionnel, ni plus, ni moins, et tu peux limiter très fortement la casse en parsant les fichiers un par un, au lieu de scanner le projet en entier : cela réduit les dépendances, donc réduction du temps de traitement. Et dans son cas précis, les dépendances ne sont justement pas nécessaires.

Je ne dis pas le contraire, mais bon... cela me semble malgré tout fort lourd, du point de vue de l'utilisation...

Généralement, on essaye quand même que l'intellisens soit relativement rapide, et l'utilisation de fichiers (quelle qu'en soit le format) risque malgré tout de fortement "plomber" les perfs... Surtout s'il s'agit d'enregistrer les fichiers après chaque modification minimes et d'attendre qu'un outil externe ait fait son boulot

Mais ce n'est pas forcément une mauvaise idée en soi pour la faisabilité et/ou les essais primaires.

Peut-être...

Mais je n'en suis pas convaincu

C'est apparemment la méthode qu'utilise Visual Studio pour son propre Intellisense, en tout cas. Toutefois, cela peut être largement plus difficile à mettre en place que Doxygen, notamment vis-à-vis de la grammaire : si l'on ne sait pas ce qu'est une grammaire, difficile de trouver les erreurs qui pourraient s'être glissées dedans !

C'est bien pour cela que j'ai proposé une alternative plus "centrale" dans la complexité, et que j'ai parlé de méthode "moins naïve"

**Amnell** · 21/09/2009, 19h00

Si je ne dois pas utiliser un thread, comment devrais-je procéder selon vous ?
A chaque enregistrement, ce n'est pas tellement la meilleure solution, je pense, puisqu'on n'enregistre pas forcément après chaque mot.

@koala01 >> Ton code utilise en effet Qt mais s'appuie sur des bases de C++ que je n'ai pour le moment pas. Comme je ne souhaite pas copier/coller bêtement ton travaille, je te serais reconnaissant de m'indiquer son effet car actuellement, je sèche un peu.

Merci encore à vous deux !

Parser de code pour un intellisense

Autres éditeurs

Discussions similaires

Partager

Partager