LRDE Seminar : C++ & Transformers, 21 May 2003, EPITA

14h00 : Introducing genericity -- Youssef El fassy fihry^?

Keyword: genericity, polymorphism, objects semantics, application to c++

Abstract: Primitive software components reusability is mainly based on a set of polymorphic concepts. Achieving basic genericity supposes thus a good understanding of these principles.

Yet, real genericity goes beyond that, and actually deals with the meaning of values, raising deep interrogations about what it really is.

The aim of this presentation is first to provide sufficient knowledge of these various concepts. Indeed, we re-introduce classical objects theorie results and conclusions, showing how they fail, sometimes, at expressing very simple facts.

Then, we present a new formalism for objects that decorralates their meaning and their structure. We actually even try to prove it is sound. Furthermore, simplifying this theorie leads to a direct application in c++. We call it combinatorial polymorphism.

15h00 : Metagene, a C++ metaprogram generation tool -- Francis Maes^?

Keywords: C++ metaprogramming, program-transformations, two-layer evaluation, ocaml, camlp4.

Abstract: The C++ disposes of a two-layer evaluation model. Therefore it is possible to evaluate a program in two steps: the so-called static and dynamic evaluations.

Programs executed statically - metaprograms - are written in C++ through an intensive use of template classes. Due to the verbosity of these structures, very few peoples really use C++ metaprograms. Metagene is a program-transformations tool which intent is to simplify the development of such particular programs. Because of similarities between C++ metaprogramming and fonctional programming, the chosen input language is an CAML-style one. As output, Metagene produces C++ metaprograms expressed with template classes.

Firstly we introduces Metagene. This is followed by the Metagene generation paradigm, showing how C++ metaprogramming is near to functional programming. Then we will see our additions to the core language in order to manipulate C++ structures. At this point we will be able to see some full Metagene examples. Finally we will discuss about applications and possible extensions of Metagene.

16h00 : Overloading in Tiger with Stratego -- Valentin David

Keywords: overloading, tiger, stratego, program-transformations

Abstract: Most of the languages used that support the overloading of functions, does not use the type of the returned value in the function signatures. The fact of this is that these technics bring many ambiguities to resolve and some of them are unresolvables. There some other languages like ADA that can resolve it but just on methods (and operators).

One the aim is to try to look for methods so as to resolve the most of this ambiguities. Another is to try to extends overloading on others kind of language elements, just like variables.

But the main aim is to treat overloading as a sugar and and use source to source program transformation technics, with tools like stratego.

As the Andrew Appel's language (Tiger) is a good language for experimentations and it does not contain any overloading, this language is used for applications.

16h45 : C++ parsing disambiguation in Transformers -- Clément Vasseur^?

Keywords: transformers, c++, parsing, program transformation

Abstract: C++ parsing is the most critical part of the Transformers project, which should allow us to perform various program transformations on C++ source code. The C++ grammar is well known to be very ambiguous and difficult to parse. More precisely, it is impossible to correctly parse C++ without semantic informations, such as type-name symbol tables. Our approach uses the sglr technology : instead of building a parse tree, we have a parse forest with each possible parse tree, and we must eliminate the wrong ones. This is the "disambiguation" process. Using the Stratego language, we need to gather various semantic informations from the parse forest, to be able to cut the wrong trees, because at the end we need only one tree. This part is quite complicated because C++ allows a lot of non-trivial programming constructs, like templates.

In this presentation, we will see how the Transformers project allow us to perform transformations on C++ source code, and we will focus on the disambiguation problem.

17h30 : An example of transformation with Transformers -- Valentin David

Keywords: transformers, c++, transformation

Abstract: Transformers is a project which the aim is to do source-to-source C++ transformations. Actually, the most of the work done is about the parsing and disambiguisation part. Now, we must do a transformation example.

This simple example will enable us to have a model and know how to proceed for future C++ transformations writing.

Finally, this example will show us what tools will be needed so as to make writing of this tranformations more friendly. In example, this tools are about the using of concrete syntax it transformation, the possibility to pretty-print more agreebly, etc.

Séminaire LRDE : C++ & Transformers, 21 Mai 2003, EPITA

14h00 : Parlez-vous générique ? -- Youssef El fassy fihry^?

Résumé : Aujourd'hui, la conception de composants logiciels réutilisables, repose essentiellement sur un certain nombre de variantes du polymorphisme. La compréhension de ces mécanismes est donc nécessaire pour une efficacité optimale. Plus encore, un composant générique abstrait et manipule le sens même des objets avec lesquels il communique. D'où le besoin d'un formalisme qui permet d'exprimer clairement ces notions, et qui permet ainsi de vérifier la validité d'un module. Cet exposé se veut tout d'abord une introduction à ces différents concepts, et présente quelques résultats classiques des théories des types simples et des objets. Ensuite, après avoir passé en revue quelques relations d'ordre usuelles sur les objets, nous montrerons qu'elles s'avèrent parfois inadaptées sur des exemples simples. Notre nouveau formalisme, que nous présentons alors, tente d'apporter un début de réponse à ces questions. Son application au C++ conclue cet exposé, et nous apporte une nouvelle façon d'aborder les hiérarchies d'objets.

15h00 : Metagene -- Francis Maes^?

Résumé : Le C++ dispose d'un modèle d'évaluation à deux couches. Un programme C++ est donc évalué en deux temps: l'évaluation statique (à la compilation) et l'évaluation dynamique (à l'exécution). Les programmes exécutés statiquement - les méta-programmes - s'écrivent en C++ à l'aide de l'usage massif de classes et fonctions génériques (template). Ces structures étant très verbeuses, et leur mise en place peu naturelle, elles sont assez rarement utilisées en pratique. Metagene est un langage inspiré du paradigme fonctionnel, doublé d'un processus de transformation vers du méta-code C++. Cet outil permet d'écrire des méta-programmes C++ de façon simple: sans pré-requis de programmation par template. Après une introduction de Metagene, le paradigme de génération utilisé dans le processus de transformation sera exposé. Cette partie nous permettra de bien illustrer les ressemblances entre programmation fonctionnelle, et méta-programmation C++. Nous montrerons ensuite les ajouts à la grammaire de Metagene, destinés à manipuler des structures du C++. A ce stade, nous pourrons exprimer quelques exemples complets de méta-programmes. En conclusion, nous discuterons des applications possibles de ce projet, ainsi que des limitations inhérentes à l'utilisation du C++.

16h00 : Surcharge en Tiger avec Stratego -- Valentin David

Résumé : Beaucoup des langages utilisés qui supportent la surcharge de fonctions n'utilisent pas le type de la valeur de retour dans leurs signatures. Cette technique introduit en effet, des ambiguïtés parfois non résolvables. D'autres, comme Ada 95, le font mais seulement sur les méthodes (et opérateurs). Un de nos buts est de chercher des méthodes pour résoudre ces ambiguïtés. Un autre est d'essayer d'utiliser la surcharge sur d'autres éléments du langage, comme les variables. Mais le principal but est de traiter la surcharge comme du sucre et d'utiliser les techniques de transformation de programmes avec des outils tels que Stratego. On utilisera le langage d'Andrew Appel (Tiger) car il n'a pas de surcharge à l'origine et il est adapté pour les expérimentations.

16h45 : La désambiguïsation du C++ dans Transformers -- Clément Vasseur^?

Résumé : Le projet Transformers a pour but d'établir un système de transformation de code source en C++. Une étape primordiale du processus est l'analyse syntaxique du C++, bien connue pour être un problème compliqué, car on ne peut pas parser correctement du C++ sans utiliser en même temps des informations sémantiques telles que des tables de symboles et de types. Nous avons opté pour l'utilisation de SGLR (scannerless generalized LR) qui nous permet d'utiliser la grammaire hors-contexte du standard C++, et produit une forêt de parse avec toutes les dérivations possibles pour un code source donné. L'analyse syntaxique est donc ambiguë, il faut la désambiguïser. Nous utilisons le langage de réécriture Stratego, pour mettre au point des filtres de désambiguisation qui nous donneront au final un résultat unique qui est l'arbre de syntaxe abstraite sur lequel on va pouvoir effectuer nos transformations. Nous verrons l'architecture générale du projet Transformers, et nous insisterons sur les problèmes liés à la désambiguisation et les solutions apportées.

17h30 : Exemple de transformation avec Transformers -- Valentin David

Résumé : Transformers est un projet dont le but est de faire de la transformation C++ source vers source. Actuellement, la plus grande partie du travail portait sur l'analyse syntaxique et la désambiguisation. Maintenant nous devons commencer à explorer les transformations. Un simple exemple de transformation va nous aider à avoir une méthode pour pouvoir écrire les prochaines transformations. Enfin, cet exemple va nous permettre de déterminer quels sont les outils dont nous aurons besoin pour rendre les transformations plus agréables à écrire. Par exemple, ces outils vont permettre d'utiliser la syntaxe concrète dans les transformations, de pretty-printer le source résultat, etc.

Reports and Slides

Reports and Slides are available from their own pages.

Reports

Robert Anisko, Valentin David, Clément Vasseur. Transformers: a C++ program transformation framework. CSI Seminar 0310 May 2003

Slides

Valentin David. A sample transformation with Transformers. CSI Seminar May 2003

Valentin David. Overloading in Tiger. CSI Seminar May 2003

Valentin David. Merging pretty-print description into the grammar. CSI Seminar May 2003

Francis Maes. Metagene, a C++ meta-program generation tool. CSI Seminar May 2003

Clément Vasseur. C++ disambiguation in Transformers. CSI Seminar May 2003
to top