[C++] Interpréteur de commandes

[Dragohn]

Bonjour,

Je cherche quelques avis et conseils. J'ai un projet à développer en C++(qui avance correctement), mais je cale sur une partie qu'on pourrait définir comme un interpréteur de commandes => je saisis des commandes + paramètres et ça doit exécuter la commande paramètrée associée. Je dois en plus fournir des indications en cas d'erreur de saisie de la commande, genre: commande inexistante, manque un paramètre, type du paramètre fourni incorrect... bref, quelque chose d'un minimum "intelligent" pour aider l'utilisateur.

Je suis à la recherche d'un exemple de code source de ce type d'interpréteur (même dans un langage lambda) juste pour avoir quelques idées supplémentaires que faire un truc immonde avec des if de partout. Attention, je ne chercher pas du "tout cuit", je cherche juste à pouvoir voir des choses qui m'aideraient un peu, ou me donneraient des idées.

Mais je me pose 2 questions bien spécifiques:

1. Comment vérifier lors d'une saisie que le type saisi correspond bien au type attendu? genre j'ai "int a; cin>>a;" et l'utilisateur entre des caractères. Comment vérifier la bonne saisie de l'utilisateur, et si le type ne correspond pas le remarquer?
   
2. Dans la même idée si on dispose d'une chaine (par exemple la liste de mes paramètres), peut on vérfier le type d'un des paramètres sans vérifier caractère par caractère? (ça ça m'étonnerait que ce soit possible, mais on ne sait jamais)
   

Si vous avez des idées, ou conseils, merci par avance

[LePhasme]

cin dispose d'indicateurs d'erreur, entre autre :

cin.fail() : indique si les bits d'erreurs sont bien tous à 0

cin.clear() : met tous les bits d'erreur à 0

il y en a d'autres notamment pour vider le buffer mais j'ai oublié je devrais pouvoir te dire ca ce soir.

Et ensuite avec cin.getline() tu peux récupérer une phrase complete, ensuite à toi de la spliter.

[lorinc]

yep, je serais toi, je prendrais la phrase complete dans une string, et je la parserai à la main.

après, j'aurais créé un objet pour chaque commande avec une méthode générique exe() qui prend comme argument les parramètres et qui effectue le réultat.

si les arguments ne sont pas bon, tu catch l'exeption...

pour savoir quel objet appeler en fonction de la commande, j'aurais fait une hashtable.

mais c'est très brutale comme approche

[Baldurien]

Tu as aussi la possibilité de faire des grammaires (bison, yacc, etc) et de vérifier le type en fonction du contexte. Peut être lourd ceci dit.

[theocrite]

lex/yacc juste pour analyser une ligne, c'est peut être un peu brutal

EDIT : En fait j'avais pas bien compris la question, je pensait qu'il fallait récupérer les arguments passés à un soft en ligne de commande (argc, argv).

Dans ce cas lex/yacc (flex bison) est parfait .

[Baldurien]

Et même y a pas forcément besoin de flex/bison, il peut faire un interpéteur simple en LL si sa grammaire s'y prête.

[Dragohn]

Merci beaucoup pour vos réponses!

Je me permets de développer un peu mon projet, qui va sûrement vous sembler "basique". Je dois faire un logiciel en ligne de commandes, permettant de créer, modifier, détruire des figures géométriques. J'ai bientôt fini la partie figures géométriques (classes, listes pour les gérer...). Au niveau ligne de commandes, je compte gérer des commandes du type:

• create type_figure, nom_figure, coord_x, coord_y,[liste de paramètres variable pour configurer ma figure] // creation d'une figure
  
• Move nom_figure, new_coord_x, new_coord_y // le point de référence est changé (figure déplacée donc, si elle existe)
  
• Destroy nom_figure // destruction de la figure (si elle existe)
  
• Group nom_group, [liste des figures à regrouper au sein du group] // creation d'une 'figure' resultant du regroupement de différentes figures existantes
  
• .... et d'autres suivants les nécessités
  

Mes 'limitations' sont de n'utiliser que Visual C++ 6, interdiction d'utiliser la STL ou d'autres bibliothèques... bref, tout faire à la main sous Visual C++ 6, et donc je peux oublier lex/yacc.

J'avais pensé en effet casser ma chaine de caractères à la main pour dégager la comande, et les paramètres.

D'un autre côté stocker les commandes au dans une liste ou un arbre binaire, que je parcours pour y retrouver la commande entrée (si elle existe), et une fois trouvée dans ma liste/mon arbre vérifier que les types entrées par l'utilisateur sont corrects en fonction de mon type de figure, et si c'est le cas, lancer la comande adéquate avec les paramètres fournis par l'utilisateur.

Mon 'raisonnement' me semble plutôt correct, mon problème étant de bien stocker les informations.

Suis je à côté de la plaque au niveau de mon idée, ou c'est quelque chose qui vous semble une bonne piste à approfondir?

[lorinc]

sans la STL, tu va te faire chi , déjà qu'avec...