[Conseils/Aide] Structure de mon premier programme

**HanLee** · 16/08/2008, 15h54

Le truc fou, c'est de parser du C++.

Tu devrais peut-être utiliser Boost.Wave ?

**Mikechaos** · 16/08/2008, 15h59

Envoyé par katagoto

Déjà, merci de l'intéret porté à mon travail,

Ensuite, je me suis servis des namespace pour "diviser" mon travail en plusieurs parties, la partie noyau (détection du langage, appel de la fonction) et la partie des différentes fonctions de parsage, je dois donc revenir aux namespace

Ce n'est pas du tout ce que j'ai dit (juste pour être certain qu'il n'y a aucun malentendu).

Voici ce qui résume exactement mon idée :

Envoyé par Obsidian

- Tes namespaces ne servent vraiment à rien si tes fonctions ne dépassent pas les frontières de ton application (mais bon, ils ne sont pas nocifs non plus).

- L'un des avantages du C++ est de pouvoir continuer à écrire des fonctions quand ça se justifie plutôt que d'avoir à systématiquement instancier un objet pour le principe. Ok. Cela dit, si tu débutes et que comptes faire une bibliothèque, tu devrais dès le départ concevoir ton projet avec des classes. Enfin, ce n'est que mon avis.

Bonne continuation.

Invité2 · 16/08/2008, 16h40

Merci à tous de participer à mon instruction ^^,

Envoyé par Mikechaos

Ce n'est pas du tout ce que j'ai dit (juste pour être certain qu'il n'y a aucun malentendu).

Voici ce qui résume exactement mon idée :

Bonne continuation.

D'accords, attend, j'y reviens plus bas ^^

Envoyé par HanLee

Le truc fou, c'est de parser du C++.

Tu devrais peut-être utiliser Boost.Wave ?

J'ai rien compris au site xD

Envoyé par Obsidian

(Mon message est passé à la trappe ! Mauvaise manip' sans doute).
Donc, en vrac :

- Tes namespaces ne servent vraiment à rien si tes fonctions ne dépassent pas les frontières de ton application (mais bon, ils ne sont pas nocifs non plus).

- L'un des avantages du C++ est de pouvoir continuer à écrire des fonctions quand ça se justifie plutôt que d'avoir à systématiquement instancier un objet pour le principe. Ok. Cela dit, si tu débutes et que comptes faire une bibliothèque, tu devrais dès le départ concevoir ton projet avec des classes. Enfin, ce n'est que mon avis.

- Il y a des choses que tu peux factoriser dans ton code :
Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
        for(int i = 2 ; i < nombre ; ++i)
        {
            if(i == 2)
            {
                chaine.push_back(*tableau[i]);
            }
            else
            {
                chaine.push_back(fixe);
                chaine.push_back(*tableau[i]);
            }
        }

se simplifie en :

Code :

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

1
2
3
4
5
6
        for(int i = 2 ; i < nombre ; ++i)
        {
            if(i > 2) chaine.push_back(fixe);
 
            chaine.push_back(*tableau[i]);
        }

Enfin, dans cette même fonction, tu définis directement dans le code une boucle commençant à 2 pour traiter argc et argv. Très bien, mais ce n'est pas l'objet en soi de ta fonction, et la liste de mots à concaténer pourrait venir d'une autre source.

À la place, fais plutôt une boucle qui concatène tous les mots et appelle-là, toi, avec un argument de moins :

Code :

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

std::string code = KolorEngine::implode(' ', argv+1, argc-1);

Déjà, je me sens idiot, oui plus que d'habitude, de n'avoir pas pensé à cette amélioration...

Je veux que mon code possède un maximum de structure possible, j'ai pensé à deux objet :
Le premier serait constitué de trois méthodes et un attribut : implode, appel fonction et et affiche, l'attribut serait la chaine, le constructeur prendrait comme argument argv et argc, qu'il donnerait à implode, l'attribut serait la chaine...
L'autre objet serait tout les langages validés, là j'ai trois solutions :
Soit une class hérite de l'autre et alors les parseurs agissent directement sur l'attribut chaine...
soit ce sont deux objet distinct et là, soit il prenne l'objet de la chaine en référence, pour travailler dessus, soit, il prennent juste la chaine et il retourne le résultat...

Que faire ?

Par avance merci de votre aide

**Obsidian** · 16/08/2008, 17h47

Envoyé par katagoto

Déjà, je me sens idiot, oui plus que d'habitude, de n'avoir pas pensé à cette amélioration...

Ça vient avec l'entraînement, comme tout le reste, ne t'inquiète pas.
Moi-même, il m'est déjà arrivé de passer trois jours sur un point-virgule surnuméraire.

Je veux que mon code possède un maximum de structure possible, j'ai pensé à deux objet :
Le premier serait constitué de trois méthodes et un attribut : implode, appel fonction et et affiche, l'attribut serait la chaine, le constructeur prendrait comme argument argv et argc, qu'il donnerait à implode, l'attribut serait la chaine...
L'autre objet serait tout les langages validés, là j'ai trois solutions :
Soit une class hérite de l'autre et alors les parseurs agissent directement sur l'attribut chaine...
soit ce sont deux objet distinct et là, soit il prenne l'objet de la chaine en référence, pour travailler dessus, soit, il prennent juste la chaine et il retourne le résultat...

Non, tu retombes dans les travers cités à mon deuxième paragraphe. Il ne faut pas définir de classe « pour le principe », si tu n'as pas l'intention de les instancier plus d'une fois à un même moment.

Si tu veux faire de la POO efficace, il faut cesser de raisonner de façon purement séquentielle. « Point d'entrée ici; au moment t, je fais ceci; à t+1, je fais cela; etc. ». À la place, il vaut mieux approcher le problème selon cet ordre :

- J'identifie les structures de données dont je pourrais avoir besoin et qui doivent être persistantes en mémoire. Je distingue bien la nature de chacune d'elles. C'est, d'une certaine manière, ce que tu avais commencé à faire avec tes namespaces, mais sur le code au lieu de le faire sur les données.
- Je définis des fonctions qui pourraient s'appliquer sur ces structures pour leur faire subir un traitement.
- Étant donné que ces fonctions et ces structures de données sont intimement liées, je crée un objet qui les rassemble toutes sous forme de membres et de méthodes.
- Une fois que j'ai des objets distincts avec des propriétés intrinsèques, je peux définir un workflow séquentiel qui les exploite. La plupart du temps, celui-ci tiendra dans ma fonction main().

En fait, le piège est qu'un parser n'est pas vraiment un projet typique de la POO, c'est plutôt quelque chose que l'on montre lorsque l'on apprend le traitement des langages, donc : automates, expressions régulières, une pile pour les langages de niveau supérieur, mais pratiquement aucune donnée persistante : c'est un traitement de flux : la donnée rentre, elle ressort, tout est séquentiel ... C'est le royaume du goto ! :-)

En plus, si ton objectif est de faire un coloriseur syntaxique, l'espace sert de séparateur la plupart du temps. Cela n'a donc pas beaucoup d'intérêt de fusionner en une chaîne puisque tu seras obligé de la redécouper en lexons à l'étape d'après.

Par contre, la plupart des langages peuvent être reconnus avec un simple automate à pile. Or, cet automate sert précisément à retenir l'état du contexte de ce que tu es en train d'analyser. Il en faut donc un par flux si tu veux en analyser plusieurs à la fois. Toutes les informations nécessaires à définir un contexte peuvent donc, elles, former une classe !

En outre, puisque tu lis la chaîne de gauche à droite, tu n'es pas obligé de tout faire en une fois. Je te conseille donc de créer une classe « Parser » qui contient exactement deux méthodes : « void Reset () », pour faire revenir l'automate à l'état initial, et « std::string Parse (const std::string &) » pour lui donner un morceau de chaîne à lire comme si elle venait de l'entrée standard.

En fonction de ce que tu viens de lire, soit il n'y a pas d'ambigüité et dans ce cas-là, la méthode renvoie tout de suite ce qu'elle vient de lire, en le colorisant si besoin, et en rendant éventuellement ce qu'il avait pu enregistrer lors des appels précédents, soit ce n'est pas suffisant pour prendre une décision (moitié d'un mot transmis, mot-clé dépendant de ce qui va suivre,etc.) et ta méthode renvoie une chaîne vide, tout en conservant en mémoire le morceau de chaîne que tu lui as filé (en le cumulant aux précédents si nécessaire), ainsi que l'état dans lequel elle se trouve au moment de l'appel. De cette manière, tu ne gardes en mémoire que le nécessaire et tu peux analyser un code de longueur virtuellement infinie.

Ensuite, tu dérives ta classe « Parser » pour la spécialiser dans les différents langages que tu sais reconnaître : « CParser », « ShellParser », « SyslogParser », etc. Dérivant toutes de la même classe-mère, elles hériteront toutes des mêmes méthodes et s'utiliseront de la même manière (concept de l'« interface »).

Tu obtiens donc des « outils » qui peuvent être exploités à loisir dans un programme de plus haut niveau, et de manière indépendante, en parallèle.

Invité2 · 16/08/2008, 18h48

Merci de t'interesser à mon problème :

Je crois avoir compris, en gros, il faux que je créer une class interface avec deux méthodes :

void reset()
std::string parse(const std::string &)

Mon programme démarre, il cherche le langage et instantie la class fille qui correspond, je fais une boucle pour que chaque (ou presque) argument soit parsé.

parse ajoute la chaine à un de ses attribut, si parse arrive à un résultat il le renvois, si non, il ne renvois rien...

C'est ça ?

Par avance merci de votre aide

**Obsidian** · 16/08/2008, 21h23

Envoyé par katagoto

!
Je crois avoir compris, en gros, il faux que je créer une class interface avec deux méthodes :

void reset()
std::string parse(const std::string &)

Deux méthodes ou plus, c'est à toi de voir. L'idée est de créer une classe générale qui contient tout ce qui est commun à l'analyse d'un langage, puis de la dériver pour la spécialiser à chaque fois dans un langage donnée.

parse ajoute la chaine à un de ses attribut, si parse arrive à un résultat il le renvois, si non, il ne renvois rien...

C'est pratiquement ça. Parse n'a pas besoin de stocker l'argument passé s'il peut le traiter de suite. Par contre, s'il est incomplet ou si son traitement dépend de ce qui suit, il faudra le conserver en mémoire jusqu'au prochain appel (et éventuellement plus loin si cet appel ne permet toujours pas de trancher). À toi de voir comment, le plus naturel étant bien sûr d'utiliser un membre de ta classe, comme un std::string.

Souviens-toi aussi qu'un argument seul peut quand même contenir des espaces. À toi de gérer cela comme il faut.

**HanLee** · 16/08/2008, 22h07

Bon, oui, Katagoto, Boost.Wave, c'est pas très compréhensible la doc.

Par contre, tu as touché à Boost.Spirit ? C'est plutôt facile d'accès, pour peu que tu es à l'aise en programmation fonctionnelle (manipulation des fonctions, curryfication...). Je t'ai vu jouer avec boost::function, ça devrait aller.

Boost.Spirit qui sert à faire des parseurs, des grammaires...

La doc avec quelques mini-tutoriaux : http://www.boost.org/doc/libs/1_36_0...sic/index.html
Les applications/exemples déjà faits sont là : http://spirit.sourceforge.net/reposi...w_contents.php

Un simple lexeur de C++ qui n'est pas dans le lien précédent (je sais pas pourquoi) : http://spirit.sourceforge.net/reposi...w_contents.php

Il y a des exemples tout faits, donc un qui implémente un lexeur C++ complet je crois.
Mais pour le C++ complet, prenant en compte les macros et tout, c'est Boost.Wave qu'il faut regarder (pour plus tard évidemment...).

Envoyé par Obsidian

En fait, le piège est qu'un parser n'est pas vraiment un projet typique de la POO, c'est plutôt quelque chose que l'on montre lorsque l'on apprend le traitement des langages, donc : automates, expressions régulières, une pile pour les langages de niveau supérieur, mais pratiquement aucune donnée persistante : c'est un traitement de flux : la donnée rentre, elle ressort, tout est séquentiel ... C'est le royaume du goto ! :-)

De toute façon, dès qu'on rentre dans de l'algorithmique pure et dure, la POO n'est pas un outil adapté, trop peu expressive et trop lourde.

Par contre, niveau traitement des langages, on est pas obligé de passer par du goto.
La compilation, c'est le domaine roi des langages fonctionnels comme OCaml, très adaptés au traitement symbolique, programmation avec les flux (l'entrée du parseur quoi, vue comme une liste infinie).
Récursion à tout va. On peut faire de la programmation propre ET efficace. Evidemment, tout est transformé en goto à la compilation.

**Obsidian** · 17/08/2008, 00h41

Par contre, niveau traitement des langages, on est pas obligé de passer par du goto.
La compilation, c'est le domaine roi des langages fonctionnels comme OCaml, très adaptés au traitement symbolique, programmation avec les flux (l'entrée du parseur quoi, vue comme une liste infinie).
Récursion à tout va. On peut faire de la programmation propre ET efficace. Evidemment, tout est transformé en goto à la compilation.

Naturellement, mais par goto, j'entendais surtout « monde des automates ». Goto n'est pas synonyme de programmation sale, contrairement à ce que la plupart des gens admettent. Mais ce débat-là, en revanche, se tient ici : http://www.developpez.net/forums/d75...c/pensez-goto/

**droggo** · 17/08/2008, 01h05

Gai,

Envoyé par Obsidian

Naturellement, mais par goto, j'entendais surtout « monde des automates ».

En quoi "le monde des automates" est-il lié au goto ?

**Obsidian** · 17/08/2008, 01h32

Envoyé par droggo

Gai, En quoi "le monde des automates" est-il lié au goto ?

Ben, c'est littéralement de ça qu'il s'agit : Les state machines sont un ensemble d'états fixes, depuis et vers lesquels on saute à chaque transition. Pour un même état et une même transition, on effectue invariablement le même saut, et aucune autre forme d'action.

Il n'y a aucune autre forme de structure sous-jacente dans un automate. Pas de boucle prédéfinie, pas de break, etc. Que des sauts. Aucune forme de registre non plus, si ce n'est l'état courant lui-même, et c'est là tout l'intérêt de ce type de structure.

Pour coder un automate à états finis en C, on utilise généralement une matrice de transitions représentée dans un tableau et c'est la façon la plus sensée de le faire, mais on pourrait très n'utiliser aucune variable (juste une fonction wait() pour attendre la transition) et tout coder avec des étiquettes et des gotos. Ça ferait hurler les puristes, bien sûr, mais ça remplirait très bien son office, sans utiliser de données. Que du code.

Invité2 · 17/08/2008, 12h49

Merci, je bosse sur le sujet et je reviens, mais y a une question me turlupine, si il main() supprime tout les espaces pour récupérer les ce qu'il y a entre, ça ne gardera pas l'indentation initiale, si ?

**Obsidian** · 17/08/2008, 13h09

Envoyé par katagoto

Merci, je bosse sur le sujet et je reviens, mais y a une question me turlupine, si il main() supprime tout les espaces pour récupérer les ce qu'il y a entre, ça ne gardera pas l'indentation initiale, si ?

Non, effectivement, et c'est pour ça qu'il ne faut pas passer ton code en argument sur la ligne de commande. À la place, utilises plutôt l'entrée standard. Pour la fonction main() proprement dite, c'est qui décides si tu comptes conserver les espaces (et les tabulations) ou pas, mais dans tous les cas, tu seras obligé de faire de l'analyse lexicale à un moment.

À toi de voir, donc, si tu comptes ignorer les espaces ou si tu les rebalances silencieusement sur la sortie (option qui t'intéressera plus, à mon avis). N'oublie pas qu'un blanc, de quelque nature qu'il soit (espace ou tab) a quand même une fonction de terminateur. Ils ne sont donc pas complètement transparents.

Invité2 · 17/08/2008, 13h59

dans ce cas, comment faire pour ne pas en tenir compte lors de l'analyse lexicale et de l'intégrer après, voir faire des modifs dessus ?

Je suis perdu là

**Obsidian** · 17/08/2008, 16h53

Envoyé par katagoto

dans ce cas, comment faire pour ne pas en tenir compte lors de l'analyse lexicale et de l'intégrer après, voir faire des modifs dessus ?

Je suis perdu là

La vraie question, c'est comment tu comptes coloriser ton texte. Si c'est en insérant les codes CSI (ESC [3?m

il faudra de toutes façons renvoyer le texte avec.

Donc, l'idée, c'est que tu vas lire la chaîne passée en entrée à l'analyse lexicale mais que dans tous les cas, tu vas stocker tel quel ce que tu viens de lire. Dès que tu détectes le début de quelque chose qui est potentiellement intéressant, tu l'orientes dans un tampon intermédiaire jusqu'à ce que tu aies pris une décision. Quand c'est fait, tu ajoutes la balise de couleur au tampon de sortie, tu ajoutes le contenu du tampon intermédiaire, et tu refermes la balise.

De cette manière, le flux de texte est toujours enrichi et jamais modifié.

Invité2 · 17/08/2008, 17h50

Envoyé par Obsidian

La vraie question, c'est comment tu comptes coloriser ton texte. Si c'est en insérant les codes CSI (ESC [3?m

il faudra de toutes façons renvoyer le texte avec.

Donc, l'idée, c'est que tu vas lire la chaîne passée en entrée à l'analyse lexicale mais que dans tous les cas, tu vas stocker tel quel ce que tu viens de lire. Dès que tu détectes le début de quelque chose qui est potentiellement intéressant, tu l'orientes dans un tampon intermédiaire jusqu'à ce que tu aies pris une décision. Quand c'est fait, tu ajoutes la balise de couleur au tampon de sortie, tu ajoutes le contenu du tampon intermédiaire, et tu refermes la balise.

De cette manière, le flux de texte est toujours enrichi et jamais modifié.

Déjà, merci de m'aider,

En fait, c'est une coloration syntaxique pour le web : donc ce sera basé sur du (x)html/CSS, ensuite, si je veux gérer l'indation, il faudrait que je récupère l'entré, caractère par caractère, que je regrouperais en mots, en prenant soin de contrôler les espaces en début de ligne et d'intercaller les espaces entre les mots...

C'est ça ?

Par avance merci de votre aide

**Obsidian** · 17/08/2008, 22h24

Envoyé par katagoto

En fait, c'est une coloration syntaxique pour le web : donc ce sera basé sur du (x)html/CSS,

Dans ce cas, facile : tu fais un <span class="xxxx"> dont le nom de classe correspond exactement à celui du lexon reconnu.

ensuite, si je veux gérer l'indation, il faudrait que je récupère l'entré, caractère par caractère, que je regrouperais en mots, en prenant soin de contrôler les espaces en début de ligne et d'intercaller les espaces entre les mots...

Minute, papillon. Pas tout à la fois. La réindentation, c'est un problème complètement différent.

Je pense qu'il est temps pour toi de commencer à écrire tes premières lignes. Vois si tu peux déjà reconnaître tes premiers mots, car tu vas vite t'apercevoir que ce n'est pas si simple, et reviens quand tu as un début de résultat.

Bon courage.

Invité2 · 19/08/2008, 09h57

on m'a dit de préférer boost::spirit à boost::regex, dois-je commencer avec boost::spirit ou boost::regex ?

**HanLee** · 19/08/2008, 11h54

Envoyé par katagoto

on m'a dit de préférer boost::spirit à boost::regex, dois-je commencer avec boost::spirit ou boost::regex ?

Bah, c'est quand même plus puissant boost::spirit.
Tu avais lu mon post ? Je t'ai montré plein d'exemples, ya aussi un exemple qui faisait : "cpp_to_html", dans le boost.spirit repository.