L3 Compilation
Mini Projet
Le but de ce mini projet est de créer un analyseur lexical en langage C ou java. Les étudiants développeront un programme
qui tokenise une entrée en identifiant les différents types de lexèmes (tokens). Ce projet permet d’apprendre les concepts
fondamentaux de l’analyse lexicale.
1 Objectifs du Projet
Les principaux objectifs de ce projet sont :
• Implémenter un tokenizer pour reconnaître différents types de lexèmes (identifiants, mots-clés, opérateurs, etc.).
• Gérer les erreurs lexicales et fournir des messages d’erreur appropriés.
• Produire un rapport sur les lexèmes trouvés, indiquant leur type et leur position dans le texte.
2 Description du Projet
Cette section fournit une explication détaillée du projet.
2.1 Étape 1 : Définition des Lexèmes
Les étudiants doivent définir les différents types de lexèmes qu’ils vont reconnaître. Par exemple :
• Identifiants : mots qui commencent par une lettre suivie de lettres et chiffres.
• Mots-clés : mots réservés du langage (e.g., if, else, while).
• Opérateurs : symboles pour des opérations (e.g., +, -, *, /, <=, !=, etc).
• Littéraux : valeurs numériques ou chaînes de caractères.
• Erreurs : caractères non reconnus qui ne correspondent à aucun type de lexème.
2.2 Automates et table de Transition
Les étudiants doivent concevoir les automates et la table de transition qui définit les états et les transitions basées sur les
caractères d’entrée, en précisant le type de lexème correspondant. Ils devront définir les états, les symboles d’entrée et les actions
à effectuer pour chaque transition.
2.3 Étape 2 : Pseudocode de l’Analyseur Lexical
Voici un exemple de pseudocode pour l’analyseur lexical :
Fonction tokeniser(input):
Initialiser état à ÉTAT_DEBUT
Initialiser index à 0
Initialiser tableau_de_tokens à vide
Initialiser token_temporaire à vide
Tant que input[index] n'est pas nul:
Ajouter chaque token a tableau_de_tokens
Retourner tableau_de_tokens
Fin Fonction
Fonction analyseur_lexical(input):
tokens = tokeniser(input)
Pour chaque token dans tokens:
type = déterminer_type(token)
si type == IDENTIFIANT:
// Gérer l'identifiant
sinon si type== LITERAL:
// Gérer le littéral
sinon si type == OPÉRATEUR:
// Gérer l'opérateur
sinon si type == MOT_CLE:
// Gérer le mot-clé
sinon si type == ERREUR:
// Gérer l'erreur et afficher
handle_error(message, token, position)
Fin Fonction
2.4 Étape 3 : Gestion des Erreurs
Implémentez une gestion des erreurs pour les cas où un lexème ne correspond à aucun type défini. Affichez des messages d’erreur
indiquant la position du lexème non reconnu.
Fonction handle_error(message, token, position):
Afficher "Erreur {token} : {message} a la position {position}"
Fin Fonction
2.5 Étape 4 : Rapport des Lexèmes
Générez un rapport des lexèmes trouvés, en indiquant leur type et leur position dans le texte.
Fonction print_report(tokens, token_count):
Pour chaque token dans tokens:
Afficher "Jeton : {[Link]}, Type : {[Link]}"
Fin Fonction
3 Exemple de Fonctionnement
Pour illustrer le fonctionnement de l’analyseur lexical, considérons l’entrée suivante :
int main() {
int a = 5;
float b = 3.14;
}
Lors de l’exécution du programme, l’analyseur lexical va :
• Lire le caractère int et le reconnaître comme un mot-clé.
• Lire main et l’identifier comme un identifiant.
• Lire ( et le reconnaître comme un opérateur.
• Lire int et l’identifier à nouveau comme un mot-clé.
• ....
Le rapport final produit par l’analyseur pourrait ressembler à ceci :
Jeton : int, Type : mot-clé
Jeton : main, Type : identifiant
Jeton : (, Type : opérateur
Jeton : int, Type : mot-clé
Jeton : a, Type : identifiant
Jeton : =, Type : opérateur
....
3.1 Exemples de Gestion d’Erreurs
Voici quelque exemples d’erreurs lexicales que les étudiants peuvent rencontrer lors de l’analyse du code.
3.1.1 Erreur de Caractère Non Reconnu
Considérons l’entrée suivante :
int main() {
int a = 5;
float b = @3.14;
}
Dans cet exemple, le caractère @ n’est pas reconnu comme un lexème valide. Lorsque l’analyseur lexical rencontre ce caractère,
il doit générer un message d’erreur :
Erreur @ : Caractère non reconnu à la position 18
3.1.2 Erreur de Littéral Invalide
Examinons maintenant un cas où un littéral est mal formé :
int x = 10.5.3;
Ici, 10.5.3 est un littéral numérique invalide. L’analyseur doit signaler une erreur en indiquant qu’il ne peut pas traiter cette
entrée :
Erreur 10.5.3 : Littéral numérique invalide à la position 11
3.1.3 Erreur de Fin de Fichier Inattendue
Enfin, considérons une situation où le code se termine de manière inattendue :
int main() {
int a = 5;
float b =
Dans cet exemple, le programme s’arrête sans valeur assignée à b. Cela peut être interprété comme une erreur de fin de
fichier :
Erreur : Fin de fichier inattendue, attente d'une valeur pour 'b' à la position 25
4 Bonus (Optionnel)
• Implémentez un analyseur syntaxique pour vérifier la structure des expressions basées sur les lexèmes reconnus.
• Implémentez une interface graphique avec java (Swing).
NB:
• Ce travail sera note sur 10 points de la note final de Tp.
• Plusieurs groupe avec le même travail 0.
• La date limite : Janvier 2025
• Le travail doit être fait par binôme ou trinômes.
• Fournir vos fichiers codes ainsi qu’un rapport détaille augmente d’exemples illustratifs a l’adresse: [Link]@univ-
[Link].