Utilisation des m´etaoutils existants

L’IDM am´eliore significativement l’efficacit´e des d´eveloppements par des outils g´en´eriques d´edi´es `a des tˆaches sp´ecifiques et complexes. Ces outils ont en commun qu’ils utilisent tous la mˆeme repr´e- sentation interm´ediaire correspondant `a la description structurelle des m´etamod`eles. On parle alors de m´etaoutils.

Outils pour la d´efinition de DSL Comme ´evoqu´e dans la section7.2, les compilateurs peuvent tirer parti des connaissances sp´ecifiques `a un domaine pour guider les optimisations. Des outils tels que Xtext7 _{ou EMFText}8 _{permettent de d´ecrire la syntaxe textuelle d’un DSL et de g´en´erer auto-}

matiquement l’environnement associ´e. Cet environnement dispose d’une coloration syntaxique, d’une autocompl´etion contextuelle ainsi que d’une infrastructure d’analyse statique des erreurs et d’assis- tance `a la correction dont le comportement est relativement simple `a personnaliser. Dans le cas de Xtext, le m´etamod`ele de la structure de donn´ees est inf´er´e `a partir de la description de la syntaxe du DSL. Il est donc plus simple de faire ´evoluer un langage, puisque les r´epercutions sur la structure de donn´ees sont imm´ediates.

Outils pour la transformation de mod`eles Les multiples repr´esentations interm´ediaires d’un compilateur optimisant am`enent les concepteurs `a d´efinir des transformations pour chaque repr´esen- tation et les ponts logiciels permettant de passer d’une repr´esentation `a l’autre. Dans les deux cas, il s’agit de transformer un mod`ele en un autre mod`ele. Si les deux mod`eles partagent le mˆeme m´eta- mod`ele, il s’agit d’une transformation de la mˆeme repr´esentation interm´ediaire. Si les m´etamod`eles source et destination sont diff´erents, il s’agit d’un pont entre deux repr´esentations interm´ediaires.

Des outils de mod`ele `a mod`ele (M2M) existent pour all´eger le coˆut de mise en oeuvre de telles op´erations. Certains de ces outils (e.g., ATL9 <sub>et ETL</sub>10<sub>) proposent de d´efinir de simples r`egles de</sub>

correspondance entre le mod`ele source et le mod`ele destination. L’outil est ensuite charg´e d’identifier et d’appliquer automatiquement les occurrences de toutes ces r`egles dans le mod`ele source. Si ce

7. http://www.eclipse.org/Xtext/

8. http://www.emftext.org/

9. http://www.eclipse.org/atl/

170 Chapitre 7. Compilation et ing´enierie dirig´ee par les mod`eles

1 // Code generation dispatch for a symbol instruction

2 def dispatch generate(SymbolInstruction s){

3 ’’’« s.symbol.name »’’’

4 }

5

6 // Code generation dispatch for a set instruction

7 def dispatch generate(SetInstruction s) {

8 ’’’« generate(s.dest) »=« generate(s.source) » ;’’’

9 }

Figure 7.3 – Extrait de g´en´erateur Xtend2 pour le code C des instructions GeCoS . fonctionnement est tr`es int´eressant pour des transformations simples, les r`egles s’av`erent rapidement difficiles `a exprimer lorsque les diff´erences entre le mod`ele source et destination sont trop importantes. Dans de telles situations, il est pr´ef´erable d’utiliser un langage plus g´en´eraliste pour exprimer le comportement de ces transformations.

Kermeta11 _{est un environnement de m´etaprogrammation construit autour d’un langage capable}

d’exprimer `a la fois la structure et le comportement d’un m´etamod`ele. Il constitue une alternative int´eressante, car la nature de son langage permet de d´efinir des transformations complexes tout en b´en´eficiant de fonctionnalit´es logicielles avanc´ees (e.g., programmation par aspect) et en conservant une ind´ependance vis-`a-vis de l’impl´ementation concr`ete du m´etamod`ele.

Outils pour la g´en´eration de code Les outils ax´es sur la g´en´eration d’une sortie textuelle `a partir d’un mod`ele (M2T12_{) tel que Xpand/Xtend}13_{et, plus r´ecemment, Xtend2}14_{offrent une sp´ecification}

flexible et modulaire du code g´en´er´e `a travers la gestion d’imports et d’aspects. De plus, les r`egles de g´en´eration de chaque entit´e du mod`ele supportent le polymorphic dispatch. Il s’agit d’une extension du patron de conception visiteur permettant `a un objet de visiter la fonction adapt´ee `a son type. Dans le cas du polymorphic dispatch, et `a l’inverse du visiteur, aucun artefact intrusif n’est n´ecessaire dans le code du mod`ele pour obtenir ce comportement. Ce sont les m´ethodes visit´ees elles-mˆemes qui d´efinissent le type d’objet qu’elles supportent. Ceci est particuli`erement utile dans un compilateur o`u une repr´esentation interm´ediaire est souvent d´ecrite par un arbre de syntaxe abstraite dont les nœuds sont des sp´ecialisations d’une unique d´efinition abstraite.

La figure 7.3illustre un extrait d’un g´en´erateur de code C ´ecrit avec Xtend2. Les m´ethodes dites de dispatch sp´ecialisent le comportement du g´en´erateur pour chaque type d’instruction. L’instruction SetInstruction est une affectation d´efinie par une source et une destination. Le mot cl´e dispatch assure que la fonction generate (ligne 7) est appel´ee lors de la g´en´eration d’une SetInstruction, les codes associ´es `a la source et `a la destination seront s´epar´es par l’op´erateur C d’une affectation. Une SymbolInstruction repr´esente un acc`es `a une variable scalaire, la ligne3indique que le rendu de cette instruction correspond au nom de la variable r´ef´erenc´ee. D’autre part, les triples quote de chaque fonction identifient des zones de chaˆınes de caract`eres particuli`eres, favorisant la lisibilit´e du code g´en´er´e `a travers la gestion des tabulations et des retours `a la lignes.

11. http://www.kermeta.org/

12. Model-to-Text

13. http://www.eclipse.org/modeling/m2t/?project=xpand

7.3. Utilisation de l’IDM dans les compilateurs 171 Les outils M2T associent donc des fonctionnalit´es logicielles avanc´ees `a des facilit´es d´edi´ees au domaine de la g´en´eration de code (e.g., concat´enation de chaˆınes de caract`eres, gestion des tabulations, etc.). Ils simplifient la conception de g´en´erateurs de code ais´ement adaptables `a de multiples variations de la repr´esentation interm´ediaire ou de la cible textuelle. Ces outils sont donc particuli`erement int´eressants dans le contexte d’un compilateur optimisant s’il est amen´e `a cibler de multiples dialectes ou plateformes mat´erielles.