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