Discussion :

[koala01]

Salut,

Je sais bien que ce message aurait sans doute été plus à sa place dans un forum plus généraliste, mais, comme il ne s'agit pas vraiment d'algorithmie, et que la méthode de modélisation m'importe peu, ben, voilà, je poste dans le forum dédié au langage qui sera utilisé...

Mon but est d'arriver à modéliser correctement l'ensemble de ce qui peut créer une fonction ou une procédure de langage de programmation.

Entendons nous bien, il ne s'agit nullement d'essayer d'interpréter cette procédure, simplement, de pouvoir gérer "de manière logique" son contenu, à savoir, créer un "arbre Naire" dont la racine serait la déclaration de la routine en elle meme (avec le nom, le type de retour, la liste des arguments et la liste des variables qu'elle connait) et dont le noeud enfant contiendrait le bloc d'instructions que la routine doit effectuer.

Par instruction, j'entend

• Les commentaires, prévus pour etre multilignes dés le départ
• les appels de fonctions existantes (avec ou sans récupération de la valeur renvoyée)
• les différents types de boucles (for, while, do...while) avec les parametres qui leur conviennent
• les tests Vrai faux (if... else) avec les parametres qui leur conviennent
• les tests à choix multiple (switch... case) avec les parametre qui leur conviennent...

Evidemment:

• les boucles doivent etre en mesure d'accepter un bloc d'instructions à effectuer,
• les tests vraix faux doivent etre en mesure d'accepter deux blocs d'instructions (un pour le if et l'autre pour le else) et
• les tests à choix multiples doivent etre en mesure d'accepter une liste de N bloc d'instructions, correpondant à l'ensemble des "case" envisagés (un bloc d'instruction par case)

Sans oublier que, si bloc d'instruction il y a, il s'agit de pouvoir en ajouter, en retirer, accéder à l'une ou l'autre instruction, voire, en intervertir deux à notre guise, ni que, si liste de bloc d'instructions il y a, il s'agira de pouvoir non seulement accéder à chaque bloc d'instruction de la meme manière, mais aussi de pouvoir rajouter/retirer un bloc d'instruction à n'importe quel moment

Enfin, pour corser le tout, il s'agirait de pouvoir, à tout moment, récupérer la liste des variables et des arguments déclarés, de manière à vérifier la présence de ce qu'on aurait présenté comme étant "une variable", quitte à remonter de "parent" en "parent" pour retrouver la racine de l'arbre

L'astuce, c'est que si j'ai une idée précise de ce qui doit composer chaque élément pris séparément, des méthodes qui "iront bien" avec, je n'arrive pas à déterminer "la meilleure" (ou en tout cas, la moins mauvaise) solution pour faire de manière à ce que tout ce beau monde puisse cohabiter harmonieusement au sein d'un seul et même bloc d'instructions.

C'est pourquoi je me tourne vers vous: quelqu'un aurait-il une idée sur la manière d'organiser tout cela

Merci d'avance, et, surtout, merci d'avoir eu le courage de me lire jusqu'au bout...

[loufoque]

Tu veux parser du C++ ?

[koala01]

Justement, non...

Je veux, au contraire, disposer d'un ensemble de classes qui permette de maintenir les informations, il n'est nullement question d'interpréter un langage quelconque, il est juste question de pouvoir "recréer l'arborescence" de l'algorithmie...

L'idée est bel et bien de juste arriver à un résultat ressemblant à

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
 
nomroutine
|   returntype (type de retour)
|   varlist   (liste des variables connues, y compris les arguments
|--Instruction 1 (commentaire, par exemple)
|--boucle1 (pour i = 1 à 13)
|    |-- instruction 2 (n'importe quoi)
|    |-- si (test)
|    |    |--alors
|    |    |   |--truc
|    |    |--sinon
|    |    |   |--brol
|--Selon ( mavar)
|    |--case(val1)
|    |    |--instruction 3
|    |    |--instruction 4
|    |--case(val2)
|    |    |--machin
|    |    |--bidule
|--instruction 5

que ce soit tout à fait indépendant du langage, meme si, sur base de l'abre généré on soit en mesure, de générer, finalement, n'importe quel langage procédural...(**)

On dirait même que tu voudrais modéliser l'arbre sémantique, plus que parser simplement.

Mieux meme, je ne veux pas parser quoi que ce soit... je veux juste modéliser l'arbre sémantique/procédural...

L'idée au final étant d'intégrer cela dans une application dont le but est de sortir un algorithme de type "nassichneiderman" dont l'utilisateur sera libre de créer la logique (avec un certain controle de la logique suivie, mais le problème ne se trouve pas encore là...)

[EDIT](**)Mais ca, c'est encore beaucoup plus loin dans la conception[/EDIT]

[alskaar]

tu devrais regarder les théories sur les langages et la grammaire utilisé pour
parser du C

si tu regardes les tokens utilisés dans ces grammaires tu devrais pouvoir ressortir les feuilles et les branches du langages ... et donc les objets et interactions entre que tu dois developper.

(Recherches éventuellement a LEX et YAK)

[koala01]

je ne sais plus comment le dire...

Il n'est là aucunement question de parser quelque langage que ce soit...

Il est juste question d'obtenir un arbre Naire dont les noeuds peuvent etre de différents types qui dérivent tous d'une classe mere identique, et de savoir quelle est la meilleure manière d'imbriquer tous ces types dans le développement des classes, le tout, en étant en mesure de récupérer relativement facilement le type d'un noeud quelconque auquel on aurait accéder, et de pouvoir accéder aux méthodes qui lui sont propres.

Il ne s'agit ni de récupérer les mots clé propres à un langage ou à un autre, ni d'interpréter ce qui est fait, il s'agit juste de créer l'arbre de la logique qui est suivie, le tout, en vérifiant, si possible, que la logique reste correcte (qu'on n'essaye pas, par exemple, de modifier une variable qui n'aurait pas été déclarée)

Mais comment tu veux faire ça sans parser le code ?

Simplement parce qu'il n'y a pas de code à parser...

Ce qu'il y a en définitive, c'est un gus devant son écran qui dit:

"je vais créer la fonction brol...

(il crée la fonction: la racine de l'arbre)

Cette fonction prendra tel et tel parametre, et renvera telle valeur

(il ajoute les parametres à la fonction et indique le type de retour)

j'ai besoin de telle et telle variable pour travailler,

(il ajoute les variables auxquelles il a pensé)

et avec le tout je fais:
je teste d'abord si bidul vaut 1,

(il ajoute un noeud enfant de type "test vrai faux")

et si c'est le cas, je fais ceci,

(il ajoute "fais ceci" dans la partie "vrai" du test)

sinon, je fais cela

(il ajoute "fais cela" dans la partie "faux" du test)

Puis, j'entre dans une boucle de 1 à autant

(il crée un deuxième enfant de type "boucle pour", avec le nom de la variable à utiliser comme compteur et les valeurs de départ, d'arrivée et de pas)
et dans cette boucle je fais un test de type choix multiple sur bidule(ce qui correspond à un switch case en C)
Sauf qu'à ce moment, l'application lui rétorque

"imbécile, je ne connais pas bidule"

(il crée un enfant de type "choix multiple" dans la boucle)
il le donc rajoute dans la liste des arguments...puis, réflexion faite, se dit qu'il devrait etre passé en tant que premier argument, ben, qu'à cela ne tienne, il le déplace en tant que premier argument
Il réessaie de créer son choix multiple sur bidule, et là, tout le monde est content...

L'une des valeurs possible de bidule est trois

(il ajoute un bloc d'instructions à effectuer si bidule vaut 3)

si bidule vaut trois, je fais ceci, ca et ca

(il rajoute les trois actions dans le bloc d'instruction dédié à la valeur 3 pour bidule
...

Pour ce qui est de la vérification d'une logique stricte, je n'ai aucun problème...

A aucun moment, il n'est question que l'utilisateur final n'entre la moindre ligne de code, quel que soit le langage utilisé

Le problème est, surtout, d'arriver à créer les différentes classes qui rentrent en jeu de manière la plus logique et la plus efficace qui soit...

[koala01]

En fait, pour l'instant, mon problème est de mettre au point un arbre Naire suffisemment robuste, et qui puisse supporter les différentes possibilités...

J'avais déjà fait un premier jet de l'application à laquelle je pense (pas mal réussi, d'ailleurs), mais toute la gestion de l'arbre passait par un "TTreeView" sous borland builder, avec le problème connexe que quand l'utilisateur introduisait dans un formulaire dédié à la "boucle pour" qu'il voulait utiliser tellle variable avec telle valeur de départ et telle valeur d'arrivée, on obtenait une chaine "pour i = depart à arrivée ", tres facile à placer dans un algorithme, soit, mais...

D'abord, il y a un problème de portabilité, et, ensuite, c'est pas évident à transformer dans différents langages

[HanLee]

Mais comment tu veux faire ça sans parser le code ?

Ou alors il faudrait modifier chaque ligne de code...

Par exemple :

int add(int a, int b)
{
return a + b;
}

devient...

Un truc à base de templates, d'arbre d'expression syntaxique. J'ai une idée dans ma tête mais ce serait super compliqué à mettre en oeuvre.

[HanLee]

On dirait même que tu voudrais modéliser l'arbre sémantique, plus que parser simplement.