REPUBLIQUE DU CAMEROUN REPUBLIC OF CAMEROON

Paix – Travail – Patrie Peace – Work – Fatherland

UNIVERSITE DE DSCHANG UNIVERSITY OF DSCHANG

Scholae Thesaurus Dschangensis Ibi Cordum Scholae Thesaurus Dschangensis Ibi Cordum

FACULTE DES SCIENCES FACULTY OF SCIENCES

Département de Mathematics and Computer
Mathématiques Informatique
Science Department
MASTER 1
MASTER 1
OPTION : IA
OPTION : IA

RAPPORT DE TRAVAUX PRATIQUES DE

compilation

DSL qui reconnait un programme écrit en

langage C

Noms et Prénoms Option Matricule

TAKOU GHISLAIN ANDRE IA CM-UDS-17SCI1546
DJOYA TCHOUNKE FRANCK ARMEL IA CM-UDS-18SCI0059
MPONGO EWANGUE PAGNOLE LAFORTUNE IA CM-UDS-18SCI0641
MAKAMTO KUATE HANDERSONE STEVELLE IA CM-UDS-22SCI1354
TUEGNO TAGNE LEONEL KELIAS IA CM-UDS-17SCI2515
Rédigé et présenté par :

Sous la coordination de : Pr. TCHOUPE MAURICE

Année académique : 2022-2023

Table des matières
Introduction................................................................................................................................................3
1. Présentation des outils.......................................................................................................................3
XTEXT....................................................................................................................................................4
GEMOC..................................................................................................................................................4
2. Installation des outils..........................................................................................................................5
3. Implémentation de la grammaire de notre DSL.................................................................................6
Conclusion.................................................................................................................................................10

2|Page
DSL qui reconnait un programme écrit en langage C
Introduction

La programmation est une tache assez difficile. Le programmeur doit constamment

jongler avec des concepts abstraits, des règles d'affaires et des considérations multiples. Là ne se
trouve pas le seul problème, le fait est qu’il semble tout d'abord illusoire de penser pouvoir
rassembler les « dix commandements» du développement de logiciels i.e. un ensemble fini de
lois et de dictas incarnant la vérité absolue en matière de programmation dont le respect
assurerait la place de notre programme au paradis des logiciels. Les connaissances sont plutôt
accumulées et documentées sous la forme de patrons et de « bonnes pratiques ». Un seul langage
de programmation n’est pas suffisant pour exprimer tout ce qui est possible et nécessaire à la
réalisation d'un programme .Par exemple dans une application web de petite envergure, on
dénombre déjà plusieurs langages(HTML,CSS,JavaScript,PHP,etc.)qui coexistent et remplissent
différents rôles. S'ils possèdent tous la même syntaxe, ils sont définis à l'aide de grammaires
différentes et donc, sont écrits en langages différents. Il existe des GPL (General Purpose
Language) tels que Java, C, C++… dont le but est de proposer des solutions à tout type de
problème solvable par ordinateur. Ce qui peut ne pas être la manière la plus Optimale, d’où les
DSIs. Un DSL est un langage miniature conçu afin d'accomplir une tâche très précise. Un DSL
s'oppose à un langage généraliste comme Java. Les concepts et les notations d'un DSL doivent
alors être choisis pour être suffisamment proches des objets manipulés dans le domaine traité.
Notons que les problèmes du domaine traité sont naturellement ceux pouvant être résolus par
ordinateur. Dans notre cas le problème est celui de la reconnaissance d’un programme écrit en
langage C. Pour créer un DSL qui résoudra ce problème, nous organisons notre travail comme
suit on présentera de façon générale les outils utilisés, ensuite de L’installation des outils et enfin
de l’implémentation de la grammaire de notre DSL.

1. Présentation des outils

3|Page
DSL qui reconnait un programme écrit en langage C
 Pour la mise sur pied de notre DSL nous utiliserons plusieurs outils mais l’outil par
excellence sera XTEXT.

XTEXT
Xtext est un framework développé sur Eclipse et permettant d'implémenter votre propre
DSL textuel ou même de mettre sur pied un langage de programmation générique (un GPL). Il
fonctionne sur une JVM (Machine Virtuelle Java) et est constitué de plusieurs API qui vous
permettent de décrire les différents aspects du langage que vous voulez créer et propose une
implémentation complète de ce langage. Notons que le langage développé sera alors un langage
qui s'appuie et qui surcouche le langage Java. C'est-à-dire que les objets offerts par ce framework
sont complètement des objets Java et le développement du compilateur de votre langage sera
alors écrit en Java.

Notons aussi que les langages développés via Xtext peuvent selon son tutoriel être définis
non seulement avec le langage Java, mais aussi d'autres langages tels que C, C++, C# objective
C, Python et Ruby. De plus, une fois que le DSL est mis en œuvre, son utilisation devient
indépendante de la JVM.

GEMOC
Le studio Eclipse GEMOC offre un cadre pour la conception et l'intégration des langages
de modélisation EMF. Le cadre fournit une interface générique pour brancher différents moteurs
d'exécution associés à leurs métalangages spécifiques utilisés pour définir la sémantique
opérationnelle des événements discrets et la coordination comportementale des DSL. Il intègre
également des services d'exécution génériques qui sont partagés entre les approches utilisées
pour implémenter la sémantique d'exécution, telles que l'animation graphique ou le débogage
omniscient.

Basé sur une API commune, GEMOC propose un framework pour intégrer tout type d'approche
de métaprogrammation utilisée pour définir la sémantique opérationnelle des événements
discrets dans un moteur d’exécution. Un moteur est développé en utilisant le framework
d'exécution et est spécifique à une approche de métaprogrammation. Le projet propose
différentes implémentations de moteurs. Puisqu'une partie importante de la logique est commune

4|Page
DSL qui reconnait un programme écrit en langage C
à tous les moteurs d'exécution, le framework fournit un moteur d'exécution abstrait de base qui
peut être étendu en un moteur concret pour toute nouvelle approche de métaprogrammation.

2. Installation des outils

 Installation et démarrage de XTEXT
Le plus simple pour commencer à utiliser Xtext est de télécharger la distribution
d’Eclipse correspondante sur le site officiel. Cette distribution contient déjà tous les plugins
nécessaires au bon fonctionnement d'Xtext (EMF notamment). Néanmoins, il est possible de
l’obtenir en téléchargeant Eclipse Xtext téléchargeable à l’adresse :
https://www.eclipse.org/Xtext/download.html

Une fois téléchargé, ouvrez le setup, scrollez et sélectionnez «Eclipse IDE for Java and
DSL Developers»

Figure 1: Installation de Xtext

Poursuivez juste l’installation, c’est prêt ! Eclipse Xtext est installé ! Il est nécessaire de
téléchargez ANTLR generator téléchargeable à l’adresse :

http://www.java2s.com/Code/Jar/a/Downloadantlrgenerator320jar.htm

5|Page
DSL qui reconnait un programme écrit en langage C
 3. Implémentation de la grammaire de notre DSL
Le projet consiste à concevoir un langage spécifique (DSL) utilisant Xtext, un outil de
développement de langages intégré à Eclipse, pour la reconnaissance et l'analyse de programmes écrits en
langage C. L'objectif est de créer un outil qui permettra aux développeurs de travailler avec des
programmes C de manière plus efficace et avec une syntaxe spécifique au domaine.

 Présentation du projet :
Le projet vise à développer un DSL capable de reconnaître et d'analyser des programmes C à l'aide de
Xtext. L'outil permettra de créer des fichiers source C valides, de les éditer et de générer des informations
utiles à partir du code. Il offrira également des fonctionnalités d'analyse statique pour détecter les erreurs
potentielles, les incohérences et les problèmes de qualité du code.
En utilisant Xtext, nous pourrons définir une grammaire spécifique au langage C qui permettra de
décrire la syntaxe valide et les règles de structure du code C. Nous créerons également des règles
sémantiques pour vérifier la cohérence du code et identifier les erreurs courantes.
 Ensemble des règles recensées :

 Déclaration des variables:

 Permettre la déclaration de variables avec des types primitifs et des tableaux.
 Vérifier la syntaxe correcte des déclarations de variables.
 Gérer la portée des variables.
 Déclaration et utilisation des fonctions:
 Permettre la déclaration de fonctions avec des types de retour et des paramètres.
 Vérifier la syntaxe correcte des déclarations et des appels de fonctions.
 Gérer la portée des fonctions.
 Structures de contrôle:
 Prendre en charge les instructions conditionnelles (if-else, switch-case).
 Prendre en charge les boucles (for, while, do-while).
 Vérifier la syntaxe correcte des structures de contrôle.
 Opérateurs et expressions :
 Prendre en charge les opérateurs arithmétiques, logiques et relationnels.
 Gérer la priorité des opérations.
 Vérifier la syntaxe correcte des expressions.
 Gestion des erreurs :
 Détecter les erreurs de syntaxe dans le code.
 Signaler les erreurs et fournir des informations de localisation précises.
 Importation de bibliothèques :
 Permettre l'inclusion de bibliothèques standard du langage C.
 Vérifier la disponibilité et l'utilisation correcte des bibliothèques.
 Commentaires :
 Prendre en charge les commentaires simples et multilignes.
 Ignorer les commentaires lors de l'analyse du code.

6|Page
DSL qui reconnait un programme écrit en langage C
Figure 2 Règles de notre DSL1/4

Figure 3 Regles de notre DSL2/4

7|Page
DSL qui reconnait un programme écrit en langage C
Figure 4 Regles de notre DSL3/4

Figure 5 Regles de notre DSL4 /4

 Notre démarche :

8|Page
DSL qui reconnait un programme écrit en langage C
  Définir une grammaire pour la syntaxe du langage C en utilisant Xtext.
 Définir les règles lexicales pour les jetons du langage C (mots-clés, identificateurs, opérateurs,
etc.).
 Définir les règles syntaxiques pour les différentes constructions du langage C (déclarations,
fonctions, structures de contrôle.

Figure 6 Programme C reconnu par notre DSL

9|Page
DSL qui reconnait un programme écrit en langage C
Conclusion

Dans le cadre de cet exposé, nous avons exploré le thème de la conception d'un langage
spécifique (DSL) capable de reconnaître et d'analyser des programmes écrits en langage C. À
l'aide de l'outil Xtext, nous avons pu définir une grammaire spécifique au langage C, des règles
lexicales et syntaxiques, ainsi que des règles sémantiques pour garantir la validité et la cohérence
du code.
La création d'un DSL pour le langage C présente de nombreux avantages. Tout d'abord,
cela permet aux développeurs de travailler avec une syntaxe spécifique au domaine, simplifiant
ainsi la compréhension et la rédaction du code. De plus, un DSL peut offrir des fonctionnalités
d'analyse statique avancées, permettant de détecter les erreurs potentielles, d'améliorer la qualité
du code et de faciliter la maintenance.
L'utilisation de Xtext s'est révélée être une approche efficace pour le développement de
notre DSL. Xtext fournit une infrastructure solide pour la création de langages spécifiques en
offrant des fonctionnalités telles que la validation syntaxique, l'édition assistée par l'IDE et la
génération de code. Grâce à ces fonctionnalités, nous avons pu concevoir un DSL pour le
langage C qui offre une expérience de développement améliorée.
En conclusion, la conception d'un DSL pour la reconnaissance de programmes écrits en
langage C avec Xtext présente un potentiel significatif pour les développeurs. Cela leur permet
de bénéficier d'un langage spécifique au domaine, de fonctionnalités d'analyse avancées et d'une
expérience de développement plus efficace. Le DSL offre ainsi une approche innovante pour
améliorer la productivité, la qualité et la maintenabilité des projets logiciels basés sur le langage
C.

10 | P a g e
DSL qui reconnait un programme écrit en langage C