Bonjour, Vous êtes tous cordialement invités à assister au séminaire qui aura lieu le mercredi 16 mai 2007 à 14 heures en Amphi 2 (KB). ----------------------------------------------------------------------- Le programme : *Olena, Transformers et DD* http://www.lrde.epita.fr/cgi-bin/twiki/view/Publications/Seminar-2007-05-16 OLENA 14h00 : Une bibliothèque de conteneurs en C++ via SCOOP -- Thomas Moulard DD 14h30 : Diagrammes de décision à valeurs supprimées -- Samuel Charron TRANSFORMERS 15h00 : Préprocesseur C/C++ reversible -- Quentin Hocquet 15h45 : Définition formelle de la Désambiguïsation avec des Grammaires Attribuées -- Nicolas Pierron 16h15 : Désambiguïsation guidée par la sémantique -- Renaud Durlin 16h45 : Centaur : Une infrastructure pour la transformation de C ++ -- Benoit Sigoure ----------------------------------------------------------------------- Les Résumés des exposés : ************************** OLENA Une bibliothèque de conteneurs en C++ via SCOOP -- Thomas Moulard SCOOP est le paradigme de programmation utilisé par Olena. Il permets l'expression de mécanismes utiles qui ne sont pas directement disponibles dans le C++ actuel tels que les concepts, les types virtuels ou bien les where-clauses. Ce paradigme présente également l'avantage d'être très rapide et sur car l'ensemble des vérifications sont réalisées à la compilation. Ces outils peuvent également être utilisés dans d'autres contextes tels que la réécriture de la bibliothèque de conteneurs du C++ comme nous le verrons ici. Cette présentation se déroulera en trois parties. Tout d'abord, un tour d'horizon rapide du paradigme sera réalisé. Puis, on expliquera comment implémenter une hiérarchie SCOOP via les outils fournis par les bibliothèques d'Olena. Enfin, la nouvelle bibliothèque de conteneurs sera présentée, ainsi que les nouvelles possibilités offertes par rapport à la bibliothèque traditionnelle. En particulier, celle-ci permets l'écriture de morphers pouvant effectuer des transformations sur les types de conteneurs. DD Diagrammes de décision à valeurs supprimées -- Samuel Charron Les diagrammes de décision sont des structures permettant de représenter de grands ensembles de données. Le partage de données communes aux éléments de l'ensemble permet une grande compacité en mémoire. Différentes techniques ont déjà été proposées pour certaines familles de diagrammes de décisions afin de réduire encore l'utilisation mémoire. L'une d'elles, la réduction, existe dans le domaine des Diagrammes de Décision Binaires (BDD). En appliquant cette technique aux Diagrammes de Décisions de Données (DDD), nous espérons un gain de mémoire. Cependant, la définition de la réduction doit être adaptée aux DDD et SDD (Set Decision Diagrams) afin de conserver leurs propriétés. De même la manipulation usuelle des DDD doit être adaptée pour tenir compte de la réduction. Durant la présentation, nous verrons comment nous avons réalisé l'adaptation de la réduction des BDD aux DDD. Puis à travers une implémentation générique des diagrammes de décision, nous montrerons les abstractions réalisées afin de pouvoir utiliser de manière générique cette technique aussi bien pour les BDD, que pour les DDD et SDD. TRANSFORMERS Préprocesseur C/C++ reversible -- Quentin Hocquet La transformation de programme C++ présente une difficulté supplémentaire par rapport à la plupart des autres langages: la phase de preprocessing. Il s’agit d’une étape complexe, dans la mesure où elle n’a absolument pas été pensée pour être inversible. Pourtant l’utilisateur d’un système de transformation de C++ souhaite retrouver son code d’origine, avec les directives de compilation et la mise en page initiale. Ce séminaire présentera les techniques utilisées pour rendre le processus réversible et pour créer sa réciproque. Définition formelle de la Désambiguïsation avec des Grammaires Attribuées -- Nicolas Pierron Le problème actuel de la désambiguïsation dans Transformers avec des grammaires attribuées est que l'on ne possède pas de preuve permettant de certifier cette approche. L'usage actuel des grammaires attribuées pour la désambiguïsation du C et d'une partie du C++ laisse à penser que cette méthode est correcte. Afin de supprimer tout doute, une définition et une formalisation de notre approche est nécessaire. Ce travail comporte deux volets. La première partie porte sur la preuve de la validité de l'approche utilisée dans Transformers. La seconde partie est consacrée à la correction et au re-développement des outils existants afin de correspondre au modèle défini. Désambiguïsation guidée par la sémantique -- Renaud Durlin Une approche élégante pour gérer les grammaires ambiguës consiste à utiliser un parseur LR généralisé qui produira non pas un arbre mais une forêt de parse. Une étape supplémentaire, appelée désambiguisation, survenant juste après le parsing, est alors nécessaire. Celle-ci consiste à analyser cette forêt pour obtenir l'unique arbre valide correspondant à l'entrée en prenant en compte les règles de sémantiques contextuelles. C'est cette approche qui a été retenue dans Transformers avec le formalisme des grammaires attribuées. Le travail effectué présentera une comparaison entre ce formalisme et deux autres techniques de désambiguisation : la première à l'aide d'ASF+SDF et la deuxième à l'aide du langage Stratego. Le but de cette comparaison sera double : montrer que les grammaires attribuées sont parfaitement adaptées à ce problème et exhiber les faiblesses de celles-ci par rapport aux deux autres méthodes en vue d'une amélioration possible du système utilisé dans Transformers. Centaur : Une infrastructure pour la transformation de C ++ -- Benoit Sigoure Transformers a choisi de suivre la grammaire du standard pour ses parseurs de C et C++. Ces grammaires ayant été conçues pour des parseurs LALR, elles sont relativement difficiles à manipuler lorsqu'il s'agit d'écrire des transformations ou faire de l'analyse statique. Le but de Centaur est de fournir aux utilisateurs de Transformers une bibliothèque de fonctions permettant de manipuler aisément du code C++. Elle permettra d'accéder simplement aux informations disponibles dans l'AST et ses annotations (pour répondre à des requêtes telles que: lister les éléments d'un namespace, rechercher des méthodes dans une class en fonction de plusieurs critères, lister les class parentes d'une class, etc.) -- Daniela Becker