Je programme actuellement un petit calculateur formel en CaML avec analyseur lexical, syntaxique...

Pour bien faire, j´ai décidé de mettre à profit le système d´exceptions pour signaler les erreurs de syntaxe ou de lexique lors du traitement des chaines.

Ainsi, une fonction d´extraction de valeurs flottantes renverra une exception dans le cas ou l´utilisateur entre plusieures fois le caractère ´.´. De même, la tentative d´extraire une chaine de caractère commencant par ´\"´ mais non terminée par ´\"´ lèvera une exception.

Mon problème réside dans le traitement de ces exceptions : pour que le code reste propre, il faudrait que l´utilisateur ne soit informé d´une erreur que par la fonction se chargeant de faire l´interface entre le programme et l´utilisateur : pas question que mes fonctions internes affichent des messages d´erreur à l´écran : cest le rôle de l´interface.

Le problème, c´est que pour procéder de la sorte, il faut que les fonctions appelants d´autres fonctions succeptibles de lever des exceptions soient en mesure de faire passer à leur tour l´exception ("téléphone arabe").

Mon code se résume à des :

try ... with ExceptionBidule -> raise ExceptionBidule

Afin de faire remonter les exceptions jusqu´à l´interface...

Le probème, c´est que c´est moche, redondant et très lourd sur certaines fonctions...

Comment faire pour conserver la précision de chaque exception (i.e éviter de faire : si on rencontre un exception quelconque, alors on renvoie une Exception générique qui englobe toutes les autres...) tout en évitant cette surcharge.

Un exemple parce que j´ai pas l´impression d´avoir été clair :

Soit la fonction f qui lève l´exception E
Soit la fonction g qui appelle f
Soit l´interface i qui appelle g et qui utilise la GUI pour afficher les erreurs

Comment faire pour que le code de g ne ressemnle pas à :

try f(...) with E -> raise E ?

Ah nan je disais n´importe quoi en fait : la gestion d´exceptions émises par f se fait dans i sans problèmes, y a pas ce phénomène de transmission à mettre en place (Vi je débute avec les excpetions)

Donc oubliez ce que j´ai dit

oui, en Caml comme en C++ (et probablement d´autre langage) l´exception est arrété par la première fonction capable de la traiter (en remontant). Et s´il n´y en a pas, ça plante.

A savoir que je crois (d´après mon prof d´info en tout cas) que la gestion des exception en Caml est très efficace (contrairement à d´autre langage où c´est réputé consommateur de ressource). Là une exception levé permet instantanément de vider la pile jusqu´à la bonne fonction et d´y reprendre l´exécution (dans ton cas, on ne traversera pas la fonction g car la VM stocke probablement une table enregistrant les gestionnaire d´exception (je suppose)).

Mais je ne sais pas ce que ça donne pour un programme compilé nativement.