Parser de code pour un intellisense

Version imprimable

17/09/2009, 23h24
Amnell

Parser de code pour un intellisense

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.
18/09/2009, 13h34
Mac LAK

Pourquoi pas tout simplement Doxygen, en mode "EXTRACT_ALL" et sortie XML ?
18/09/2009, 23h09
Amnell

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.
19/09/2009, 11h32
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.
19/09/2009, 12h41
Amnell

Citation:

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.
19/09/2009, 15h19
aoyou

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.
19/09/2009, 17h23
Amnell

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 :

Citation:

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 ! :aie:
19/09/2009, 18h37
aoyou

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 ?
19/09/2009, 19h03
Amnell

Citation:

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 :aie:
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 !
19/09/2009, 19h22
aoyou

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.
19/09/2009, 19h51
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.

Sinon, il y a aussi moyen d'ajouter un langage à Visual Studio, via un add-in, mais ça ne sera pas portable.
19/09/2009, 21h37
Amnell

Citation:

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

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:

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.

19/09/2009, 23h20
Amnell
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:

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; }
20/09/2009, 00h08
koala01

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 :question:)

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 ;)
20/09/2009, 11h56
Amnell

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.

Citation:

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

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

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

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

Citation:

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

21/09/2009, 10h37
Mac LAK

Citation:

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

Citation:

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.

Citation:

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 ! ;)
21/09/2009, 12h50
koala01

Citation:

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

Citation:

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

Citation:

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

Citation:

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" ;) :D
21/09/2009, 18h00
Amnell

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 !
21/09/2009, 18h05
Mac LAK

Citation:

Envoyé par zAmnellL

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.

Ah, dans un thread, c'est possible, mais en tâche de fond lors de la compilation plutôt... Lors d'une compilation, ce temps sera plus ou moins négligeable le plus souvent, et c'est à la limite un comportement courant (VC++ procède ainsi, par exemple : la base des symboles n'est créée qu'à la compilation). Alors que si c'est fait à chaque sauvegarde, ou de façon "continue", ça va très vite devenir abominablement lent.
21/09/2009, 18h17
Amnell

Enfin, je sais que QtCreator par exemple actualise directement sa banque de données de fonctions/classes/variables/autres lors de l'écriture.
Mais il est vrai que pendant la compilation, puisque l'utilisateur ne fait généralement plus rien, on pourrait lancer le parser... mais s'il ne compile pas avec l'IDE, j'ai l'air idiot ! :aie:
21/09/2009, 18h27
Mac LAK

Citation:

Envoyé par zAmnellL

mais s'il ne compile pas avec l'IDE, j'ai l'air idiot ! :aie:

C'est à dire ? L'analyse est (presque) indépendante de la compilation !
A la limite, tu peux faire "propre" en ne prenant pas en compte la nouvelle analyse en cas d'erreur de compilation, mais à part ça...
21/09/2009, 18h39
Amnell

Je veux dire qu'il n'est pas obligé de passer par l'IDE pour compiler, et dans le cas où il ne s'en servirait effectivement pas, ma banque de données ne s'actualiserait pas...
22/09/2009, 10h08
Mac LAK

S'il n'utilise pas l'IDE, il n'a pas besoin de l'Intellisense... :mouarf:
22/09/2009, 15h52
Amnell
Si justement car l'intellisense permettra de rendre meilleur le completer.
Exemple :
Code:

1 2 QString s; s.
>> A l'écriture du point, l'intellisense est sensée avoir indexé la variable "s" de type QString : le completer sortira donc les fonctions associées à la classe QString et non les fonctions des autres classes.
22/09/2009, 16h10
Mac LAK
Mais là, tu ne t'en sors pas, je t'explique :
- Ton souci est que l'intellisense ne sera pas mis à jour s'il compile en dehors de l'IDE.
- Or, s'il compile en dehors, c'est déjà qu'il n'utilise pas complètement l'IDE.
- Donc, tant pis pour sa pomme : s'il compile en dehors de l'IDE, pas de complétion, et c'est logique car c'est une fonction de l'IDE, et non pas du compilateur ! ;)
22/09/2009, 17h07
Amnell

Présenté comme ça...
Bref, si c'était possible de me commenter un peu le code donné, ça m'aiderait beaucoup et ça serait meilleur pour ma conscience (je déteste faire des c/c, et encore plus quand je ne comprends pas le code). :ccool: