Bonjour,
 
   De manière générale, je cherche des informations pour réaliser un interpreteur ('parser'). Existe-t-il des modèles pour réaliser une telle fonction en C++. Le C++ est-il vraiment adapté à ce genre de fonction ?
 
   Je suis pret à coder ce parser "from scratch", mais je préfere demander l'avis du public avant de commencer !    
 
Cordialement,
   Xter.

Lexx yacc...plutot en C

bouquin (au passage) = "compilateurs, principes techniques et outils"..alias dragon book

Lex, je vais finir par regarder, ce n'est pas la première fois que j'en entends parler !
 
Merci,
   XteR.

flex

ui c vrai...version GNU...vek bison

Par contre j'aurais du preciser une chose importante : c'est une fonction logicielle destimée à être enfouie (execution par un microcontroller) -> je n'ai qu'un compilateur C/C++ à ma disposition. Lx/Flex/Lexx/truc se basent sur du C/C++ ?
 
Merci,
   XteR.

ça génére le code C

Tres bien, c'est parfait. Merci.

ou du code C++ à la demande

exacte : `%option c++'
je l'ignorais

Effectivement, flex génère du code en C ou C++ mais le code en question n'est pas autonome (il faut linker avec une libriarie). Il faut déja que j'arrive à compiler cette lib sur la cible qui m'interesse. A vérifier donc...
 
Xter.

 
C'est un peu off topic, mais pour ceusse qui se lancent dans l'écriture d'un langage applicatif, j'en profite pour signaler le langage Objective Caml qui est idéal pour l'écriture d'interpréteurs/compilateurs (c'est même l'un de ses usages premiers, le compilo lui-même étant écrit en ocaml). Le coeur du langage est assez facile à apprendre et par rapport à C++, nul doute que ce langage te facilitera la tâche, notamment grâce au pattern matching.
 
http://www.ocaml.org
 
Il me semble que quelque part dans la doc, il y a un exemple où on écrit un interpréteur Basic en quelques centaines de lignes.
En attendant, voici une page où l'on donne un exemple de lexeur :
http://caml.inria.fr/ocaml/htmlman/manual003.html
Ocaml possède aussi un Lex et Yacc, ainsi que des macros puissantes.
 
L'autre solution valable et qui peut faire gagner un temps précieux, est d'embarquer un interpréteur Scheme écrit en C comme SIOD, Elk ou Guile, et de développer un maximum de choses en Scheme :
http://www-rn.informatik.uni-bremen.de/software/elk/
http://www.cs.indiana.edu/scheme-r [...] p/siod.htm
http://www.gnu.org/software/guile/
 
A ce sujet, ce qui est écrit ci-dessous est vérifié presque systématiquement. Le langage d'extension, qui est au départ une fonctionnalité annexe devient assez vite un point central de l'application. Si on en a la possibilité, c'est beaucoup plus simple et puissant d'apprendre Scheme que d'écrire un nouvel interpréteur "from scratch".
 

J'ai aussi entendu parler du calm. Et concernant le sceme, ca me rappelle l'école et les cours de programmation (lisp).
 
Merci,
Xter.
 

Très bien, mais ce n'est pas parce que tu l'as appris à l'école que ce n''est pas sérieux.
Si ce langage est enseigné, c'est justement parce qu'il permet d'aller rapidement à l'essentiel, l'algorithmie, sans s'encombrer de choses annexes (gestion de la mémoire, pointeurs, etc, avec tous les bugs que ça amène), ce qui est exactement ce que désire l'utilisateur d'un langage d'extension.

* el muchacho ->  
- Est ce que le parser produit est correct en temps de traitement ? (est ce qu'il y aurait des benchs comparatifs dispo quelque part ?)
- Est ce qu'il y aurait quelque part un retour d'experience disponible qui comparerait les gains en temps de développement et évolution par rapport à un projet en C/C++ ? (peut être pas complet mais au moins sur l'implémentation de quelques fonctionnalitées comme la gestion mémoire)
* xterminhate ->
Juste par curiosité : quel compilo et quel microctrl ?
Et tjrs par curiosité Pourrais tu nous tenir au courant ?

Il s'agit d'un developpement pour microcontrolleur motorola à coeur 68000.
 
Si vos conseils m'ont eclairé dans le domaine des analyseurs syntaxiques (ca m'a donné une idée pour recoder un programme que j'ai réalisé il y a peu de temps)), je m'oriente toujours vers une solution C/C++ fait maison car le langage à interpreter est relativement simple dans mon cas et que le pauvre microcontroller que j'ai tourne vraiment pas vite .
 
Cordialement,
 xter.

 
Tu parles de quel langage ? Pour Ocaml, les exécutables sont très rapides, sans doute comparables à du C++ pour ce qui est d'un parser. Pour Scheme, c'est un interpréteur, donc il ne faut pas s'attendre à des perfs ultimes. De plus, les perfs sont je suppose très dépendantes de l'implémentation. Le bench le plus complet que je connaisse est  
http://www.bagley.org/~doug/shootout/index2.shtml
http://dada.perl.it/shootout/
Ocaml est très bien placé, mais comme tous les benchs, c'est à prendre avec des pincettes.
Pour ce qui est du gain de temps en implémentation, je ne connais pas d'étude sérieuse, à part peut-être http://www.theadvisors.com/langcomparison.htm (malheureusement, ocaml n'y est pas, mais je le mettrais autour de 15-20). Ocaml intègre un ramasse-miettes, donc pas de gestion mémoire. Mais ce qui fait gagner du temps, c'est le pattern matching et la programmation fonctionnelle, et la sûreté du langage (typage fort, pas de pointeurs).
 
Quand à Scheme, à part l'intégration dans l'application, il n'y a rien à faire, le langage est prêt à être utilisé tel quel.

ok, bon courage then..
 
68000 => 1979 mais quand même registre 32 bits, 16 bits pour le bus de données (a la meme epoque chez intel z'en etaient encore à du 16/8)...déja pas mal
Ca a fait le bonheur de nombreux ataristes et autres amigatistes....

thanks pour les liens et les précisions muchacho....c'est exactement ce que je cherchais..

Effectivement le coeur commence un peu à dater, mais c'est un microcontroller... c'est qd même mieux qu'un 8051

et des possesseurs de TI

 
En ayant codé un certain nombre, le C (ou le C++) est très adapté pour l'implémentation d'un parser solide et rapide. D'une manière très générale, l'histoire ressemble toujours à
- une grosse boucle sur le texte à parser
- quelques indicateurs d'état
- quelques pointeurs de position (début d'un mot, fin d'un mot, début d'une expression, ..., le tout pouvant être dans une structure ou une classe si on a besoin de se trimballer à droite ou à gauche les infos)
- un switch sur le caractère courant pour maintenir et updater tout ça
- une fonction chargée d'interpréter les mots et de produire la sortie
- un switch sur le retour de la fonction afin de se remettre dans un état correct selon le résultat et la tolérance aux erreurs du parser
 
Bref, c'est assez facile à faire sauf, peut-être, pour le tout premier et, en général, c'est plutôt rigolo.