Réalisation d'un compilateur de mini langage - Khawarizmi

REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
MINISTERE D’ENSEIGNEMENT SUPERIEUR
ET DE LA RECHERCHE SCIENTIFIQUE
Faculté Des Sciences Et De L’ingénierie
Institue De Génie Informatique
Module Compilation
4 éme
Année Informatique
BENYAMMI Bachir & HASSANI Mustapha
Encadré par : M. ALLAOUI Taher
Année Universitaire
2006-2007
Réalisé par :

Compilateur KhawarizmiSommaire
2
Sommaire
Sommaire………………………………………………………………………….. 2
Statut actuelle du mini projet……………………………………………………… 3
Compilation, Notions et définitions……………………………………………….. 4
Pourquoi Khawarizmi ?........................................................................................ 4
Langages de programmation………………………………………………...…. 4
Programme…………………………………………………………………….... 5
Compilateur…………………………………………………………………..… 5
Etapes de la compilation…………………………………………………….. 5
Découlement de la compilation……………………………………………... 6
Interpréteur……………………………………………………………..……… 7
BNF & EBNF……………………………………………………………..…… 7
Syntaxe d'une règle EBNF………………………………………………….. 7
Explication des règles EBNF……………………………………………….. 8
Diagrammes syntaxiques……………………………………………………….. 8
Khawarizmi………………………………………………………………………... 9
Pourquoi le langage Khawarizmi ?...................................................................... 9
Avantages du Khawarizmi................................................................................... 10
Future améliorations............................................................................................ 10
Le jeu de caractères............................................................................................. 10
Les unités lexicales.............................................................................................. 11
Les automates et les expressions régulières......................................................... 12
Tables des transitons ........................................................................................... 15
La table de symboles........................................................................................... 17
Chaîne de références............................................................................................ 18
Mémoires de stockage......................................................................................... 18
Fonctionnement général du Khawarizmi............................................................. 18
L'analyse lexicale................................................................................................. 19
Règles EBNF du Khawarizmi............................................................................. 20
Règles de la grammaire....................................................................................... 21
Les ensembles premier et suivant........................................................................ 22
Diagrammes syntaxiques..................................................................................... 25
Mise en œuvre de l'analyseur lexicale…............................................................. 31
Mise en œuvre de l'analyseur syntaxique............................................................ 31
Mise en œuvre de l'analyseur sémantique........................................................... 31
Gestion des erreurs.............................................................................................. 31
IHM..................................................................................................................... 32
Structure générale de l'application....................................................................... 32
Problèmes rencontrés ……………….…………………………………………….. 33
Historique du Khawarizmi……………………………………………………... 33
Conclusion................................................................................................................. 34
Bibliographie............................................................................................................. 35

Compilateur KhawarizmiStatut
3
Statut
Statue actuelle du mini projet
Malgré l'absence d'une salle de TP, et d'une connexion Internet, et des ouvrages au niveau
de la bibliothèque de l'université de Laghouat; on à essayer de construire étape par étape notre
compilateur, et on a arrivé à réaliser la première phase du compilateur (phase d'analyse: lexicale,
syntaxique, sémantique) par la définition de:
 Jeu de caractères;
 Unités lexicales (Mots réservés, Identificateurs, Constantes, Opérateurs, Séparateurs, …);
 Règles d'expression;
 Automates et automate union;
 Table des transitions (états, symboles, ensembles);
 Table des symboles;
 Chaîne de références;
 Mémoires de stockages;
 Règles EBNF;
 Transformation de la grammaire en LL (1);
 Ensembles Premiers et Suivants;
 Diagrammes syntaxiques;
 Procédures de la descente récursives;
 Arbre syntaxique;
 Définition et contrôle et évaluation des types (Entier, Naturel, Logique, Caractère,
Chaîne);
 Evaluation des expressions (Arithmétiques, Conditionnelles, Logiques, …);
 Gestion des erreurs (lexicales, syntaxiques, sémantiques);
 IHM du compilateur;
 …

Compilateur KhawarizmiCompilation, Notions et définitions
4
Compilation,
Notions et définitions
Pourquoi Khawarizmi ?
En 820, Le mathématicien El Khawarizmi publie à Bagdad un traité intitulé "La science
de l'élimination et de la réduction" qui, importé en Europe Occidentale au début de l'islam aura
une grande influence sur le développement des mathématiques.
Aprés 1000 années (1840), le collaboration de Babbage, Ada Lovelace, définit le principe des
itérations successives dans l'exécution d'une opération. En l'honneur du mathématicien Arabe
El Khawarizmi (820), elle nomme le processus logique d'exécution d'un programme :
algorithme.[1]
Langages de programmation
Les langages de programmation ont été nés avec l’apparition des ordinateurs, ils ont été
fondus essentiellement pour effectuer les grands calculs comme le langage fortran 1954.
Comme tout langage naturel écrit, un langage de programmation se compose de lettres, de
nombres et de caractères spéciaux obéissant à des règles de syntaxe et de sémantique. Un
langage est destiné à décrire l'ensemble des actions consécutives qu'un ordinateur doit exécuter.
En fonction de l'environnement matériel, on distingue les langages d'assemblage des langages de
programmation évolués.
Un langage d'assemblage présente les instructions du langage machine binaire d'un processeur
sous la forme d'un code mnémonique et fonctionne à partir d'instructions d'assemblage pour la
définition de structures de données, de macros, de procédures, etc. Pour obtenir un programme
exécutable,
le programme source est ensuite traduit (assemblé) par un assembleur en un module objet.
Un ou plusieurs modules objet peuvent être reliés par un éditeur de liens au programme
exécutable.
Les langages de programmation évolués sont orientés vers les problèmes qu'ils résolvent par des
algorithmes. Ils se composent d'instructions générales et ne sont pas destinés à un ordinateur en
particulier. Néanmoins, il faut s'assurer dans chaque cas que l'ordinateur utilisé dispose des outils
nécessaires (au minimum, le compilateur du langage choisi). [2]

5
Programme
Un programme est un simple fichier texte (écrit avec un traitement de texte ou un éditeur
de texte). Il contient une succession d'instructions exécutable par l'ordinateur.
Toutefois, l'ordinateur ne sait manipuler que du binaire, c'est-à-dire une succession de 0 et de 1.
Il est donc nécessaire d'utiliser un langage de programmation pour écrire de façon lisible, c'est-à-
dire avec des instructions compréhensibles par l'humain car proches de son langage, les
instructions à exécuter par l'ordinateur. Ainsi, ces programmes sont traduits en langage machine
(en binaire) par un compilateur.
La façon d'écrire un programme est intimement liée au langage de programmation que l'on a
choisi car il en existe énormément. De plus, le compilateur devra correspondre au langage choisi:
à chaque langage de programmation son compilateur. [3]
Le programme source écrit dans un langage de programmation évolué est traduit et exécuté
progressivement en code machine par un interpréteur (comme le BASIC, dBASE), ou est traduit
en un ou plusieurs modules objets par un compilateur (comme PASCAL). Ces modules objets
peuvent être reliés dans le programme exécutable à d'autres modules objets ou à des composants
prélevés dans une bibliothèque de modules objets par un éditeur de liens.
Compilateur
Un compilateur est un programme qui permet de traduire un programme source écrit dans
un certain langage en un programme cible dans un autre langage. Le plus souvent, le langage
cible est le langage machine.
Un compilateur fonctionne par analyse-synthèse, c'est-à-dire qu'au lieu de remplacer chaque
construction du langage source par une suite équivalente de constructions du langage cible, il
commence par analyser le texte source pour en construire une représentation intermédiaire qu'il
traduit à son tour en langage cible. [4]
Etapes de la compilation
 le découpage du programme en lexemes et le remplissage de la table de symbols
(analyse lexicale);
 la vérification de la correction de la syntaxe du programme (analyse syntaxique) ;
 l'analyse des structures de données et le contrôle de type (analyse sémantique);
 la gestion des erreurs;
 la transformation du code source en code intermédiaire ;
 l'application de techniques d'optimisation sur le code intermédiaire;
 l'allocation de registres et la traduction du code intermédiaire en code objet, avec
ventuellement l'insertion de données de débogage et d'analyse de l'exécution ;
 et enfin l'édition des liens.

6
Fig. 01: Etapes de compilation.
Déroulement de la compilation
L'exemple suivant montre le déroulement de la compilation pour une instruction donnée.
Fig. 02 : Déroulement de la compilation

7
Interpréteur
Certains compilateurs ne possèdent pas de phase de génération de code en langage
machine. Ils s'arrêtent à la production de code intermédiaire. L'exécution du programme source
consiste alors en une interprétation du code intermédiaire par un programme appelé interprète
ou interpréteur. Quelquefois, l'interprète exécute directement le langage source, comme en Basic.
Le plus souvent, il exécute un code intermédiaire fabriqué par un compilateur.
L'intérêt d'une interprétation du langage intermédiaire est la portabilité du compilateur ainsi créé:
le groupe de Wirth à Zurich diffusait le langage Pascal en fournissant la source d'un compilateur
Pascal en P-Code et la source Pascale d'un interprète P-Code. Pour porter Pascal sur sa machine,
il suffisait de réécrire un programme équivalent à l'interprète fourni.
Le désavantage d'une interprétation est une baisse de performance des programmes ;
l'interprétation étant souvent plus lente que ne le serait l'exécution de code machine optimisé d'un
compilateur complet. [5]
BNF & EBNF
BNF (Backus Naur Form) est une notation permettant de décrire les règles syntaxiques
des langages de programmation. Elle est utilisée dans certains livres pour expliquer et étudier la
syntaxe d'un langage, mais également par de nombreux logiciels d’analyse syntaxique. [6]
BNF est une notation pour des grammaires de type hors contexte (algébrique ou type 02), elle est
conçu par John Backus et Peter Naur lors de la création de la grammaire du langage ALGOL
60.
EBNF (Extended Backus-Naur form) est comme son nom l'indique une extension du BNF,
elle est créée par Niklaus Wirth dans les années 70 lorsqu'il à développé le langage PASCAL.
Cette forme permet de condenser la notation BNF et de la rendre plus lisible. [7]
Syntaxe d'une règle EBNF
Désignation Ecriture
Règle de production S donne E S = E
Ou exclusif de termes syntaxiques E = T1 | T2 |...| Tn
Concaténation des facteurs des termes Ti Ti = F1 F2...Fn
Vide ou une occurrence de E Fi = [ E ]
Nombre quelconque d'occurrences de E y compris 0 Fi = { E }
Symbole terminal Fi = "x"

8
Explication des règles EBNF
 Les règles de production sont de la forme S = E. Où S c'est l'unité syntaxique et E une
expression dont la valeur définit l’ensemble de toutes les séquences de symboles que
comprend l'unité S.
 L’expression E est de la forme: T1 | T2 | . . . | Tn ( n > 0). où les Ti sont les termes de E. La
valeur de E est la réunion des valeurs des Ti.
 Chaque Ti est de la forme: F1F2 . . . Fn (n > 0). Où les Fi sont les facteurs de T. La valeur de
T est la concaténation des valeurs des Fi.
 Chaque facteur est
 soit de la forme: “x”. Où x est un symbole du langage et “x” désigne l’ensemble formé
d’une seule séquence d’un seul élément: x;
 soit de la forme: S qui a pour valeur celle de l’expression qui définit S ;
 soit de la forme: (E) qui a pour valeur celle de E,
 soit de la forme: [E] qui a pour valeur la réunion de la valeur de E et de la séquence vide
(E | ε),
 soit finalement de la forme: {E} qui a pour valeur la réunion de la séquence vide avec les
séquences désignées par E, EE, EEE, ….[8]
Diagrammes syntaxiques
Est une autre méthode de spécification de la syntaxe des langages de programmation, ces
mêmes diagrammes syntaxiques peuvent d’ailleurs être traduits en instructions de programme
et former ainsi un analyseur syntaxique.
Les diagrammes syntaxique ont été utilisés pas Niklaus Wirth pour d'écrir la syntaxe du
compilateur PASCAL en 1971. [8]

Compilateur KhawarizmiKhawarizmi
9
Khawarizmi
Pourquoi le langage Khawarizmi ?
A l'heure actuelle; des milliers de langages existent, en citons les plus connus: C, C++,
JAVA, Pascal, PHP, ... La majorité des langages utilisent les lettres anglo-saxonnes pour définir
l’ensemble des identificateurs, et les messages d’erreurs sont exprimés en anglais.
Des dizaines du Langages de programmation arabes on été construites :
 ‫ﻏﺮﯾﺐ‬–‫اﻟﻌﺮاق‬1978
 ‫ﺑﯿﺴﻚ‬ –‫اﻟﻜﻮﯾﺖ‬1981
 ‫ﺳﯿﻨﺎ‬–‫اﻟﺴﻮدان‬1986
 ‫اﻟ‬‫اﻟﻌﺮﺑﻲ‬ ‫ﺒﺎﺳﻜﺎل‬–‫اﻟﺴﻌﻮدﯾﺔ‬1996
 ...
La plupart de ces langages n’ont été pas réussites, parmi les causes on distingue :
 Les différents codages des lettres arbres.
 La faiblesse de la maintenance et de la mise à jour.
 Les problèmes financiers.
 L’existence des langages standards et puissants (JAVA, C++, Pascal,…).
Un langage de programmation en arabe peut faciliter la tâche aux élèves des collèges et aux
lycéens à comprendre les principes et les notions d’algorithmique et d'apprendre la
programmation.
L'idée est de développer un langage destiner à l'enseignement qui combine à la fois la facilité du
Pascal (utilisation des mots naturels tel que Program, Begin, End, ..) et l'abréviation utilisé dans
la structure du C ({}, ||, &&, !, …).

10
Avantages du Khawarizmi
 Code source en arabe;
 Lettres arabe et latins (plus de 60 lettres);
 Chiffres et caractères spéciaux (plus de 25 caractères) ;
 Déclaration des variables et des constantes;
 Divers types simples (Entier, Naturel, Logique, Caractère, Chaîne);
 Boucles et expressions conditionnelles;
 Commentaires;
 Opération arithmétiques, conditionnelles, comparaisons, affectations, …
 Lecture et écriture (Entrée-sortie);
 Détection et consultation des erreurs avec possibilité de correction;
 …
Future améliorations
 Utilisation des procédures et des fonctions;
 Ajout des types complexes tel que les réels et les tableaux;
 Ajout d'autres types de boucles et d'expressions conditionnelles;
 Terminaison de la 1ére
partie du compilateur (Analyse: Lexicale, Syntaxique, Sémantique)
 Réalisation de la 2éme
partie (synthèse : génération et optimisation du code, …).
 Réécriture du code: la programmation d'un compilateur nécessite l'utilisation des notions
de classes, héritage, construction, propriétés, méthodes, …; alors un langage orienté
objets est préférable tel que : JAVA, C++.
 Adaptation pour d'autres plateformes tel que : Linux, Unix, Solaris, …
 Support pour la langue arabe (Interface, boite de dialogue, messages, …)
Le jeu de caractères
Le jeu de caractères représente tous les caractères autorisés (presque 130 caractères) :
 Les lettres arabes et latines.
 Les chiffres.
 Les séparateurs : {, }, (, ), ‫؛‬ , ، , . , : , , "
 Les opérateurs : + , - , *, ÷ , % , = , ~ , # , < , > , » , « , ! , & , |
 Les caractères de contrôle tel que : blanc, tabulation, null (c'est à dire les
caractères entre 0 et 32 du code ASCII).

11
Les unités lexicales
 Les mots réservés
‫ﻣﻨﻄﻘﻲ‬ ‫ﻣﺘﻐﯿﺮ‬ ‫ﺛﺎﺑﺖ‬ ‫ﺑﺮﻧﺎﻣﺞ‬
‫رﻣﺰ‬ ‫ﺳﻠﺴﻠﺔ‬ ‫ﻃﺒﯿﻌﻲ‬ ‫ﺻﺤﯿﺢ‬
‫ﻓﺎن‬ ‫اذا‬ ‫ﻗﻢ‬ ‫ﺑﯿﻨﻤﺎ‬
‫ﻻ‬ ‫ﻧﻌﻢ‬ ‫واﻻ‬
‫اﻗﺮا‬ ‫اﻃﺒﻊ‬
 Les opérateurs
=, +, -, *, ÷, %, ~, #, > , < , », «, |, &, !
 Les séparateurs
{, }, (, ), ., ‫,؛‬ ،, :,
 Les identificateurs
Un identificateur est un mot composé de lettres (arabes et français), de chiffres et du
caractère "_" et commençant obligatoirement par une lettre. La case sensitive n’est pas
respectée, la longueur max d’un identificateur est 64 caractères.
Les ensembles suivants sont considérés comme des identificateurs
 Le nom du programme;
 Les mots réservés;
 Les variables;
 les fixes (constates déclarées).
 Les nombres
Suites de chiffre entre 0 et 9, seulement les nombres entiers sont acceptés.
 Les commentaires
Notre mini langage permet d’insérer des commentaries.
 Si les commentaires peuvent tenir sur une seule ligne elles doivent commencer par .
 Si elles peuvent tenir sur plusieurs lignes, alors elles doivent être mises entre et .
 Les commentaires ne peuvent pas être imbriqués.

12
Les automates et les expressions régulières
Fig. 3 : Automate de l'Identificateur
Ident -> Lettre (Lettre / Chiffre)* #
Fig. 4 : Automate de Nombre
Nbr -> Chiffre (Chiffre)* #
Fig. 5 : Automate de Chaîne de caractères
Chaine -> '"' ( # )* '"'
Fig. 6 : Automate de Commentaire
Comm -> '' '' ( # )* EOL
Fig. 7 : Automate de Commentaire multi lignes
Comm.multi -> '' # ( # )* ''
0 10
‘’ # de ‘’ ‘’
117
8
‘’
EOL 9
# de EOL
# de ‘’
2
L | C
3
C
C
1
L# de L et C
4
# de C Sep
5 6
Opr
Blanc
‘"’
‘"’
12 13
# de ‘"’
Fig. 8 : L’automate d’état fini union déterministe du langage

13
‫ﺑﺮﻧﺎﻣﺞ‬
‫ﺛﺎﺑﺖ‬
‫ﻣﺘﻐﯿﺮ‬
‫ﻣﻨﻄﻘﻲ‬
‫ﺻﺤﯿﺢ‬
‫ﻃﺒﯿﻌﻲ‬
‫رﻣﺰ‬
‫ﺳﻠﺴﻠﺔ‬
‫ﻧﻌﻢ‬
‫ﻻ‬
‫ﺑﯿﻨﻤﺎ‬
‫ﻗﻢ‬
‫اذا‬
‫ﻓﺎن‬
‫واﻻ‬
‫اﻗﺮا‬
‫اﻃﺒﻊ‬
Fig. 9 : Les automates des mots réservés

14
Fig.10:L’automated’étatfiniuniondéterministedesmotsréservés.

15
Tables des transitons
Etat initial : Etat_Initial.
Etats finaux :
Etat_Diff_Ident, Etat_Diff_Nbr, Etat_Sep, Etat_Opr, Etat_Ligne_Comn,
Etat_Mul_Lignes_Comm, Etat_Fin_Chaine, Etat_Erreur.
Ensemble d’états :
Etat_Initial, Etat_Ident, Etat_Diff_Ident, Etat_Nbr, Etat_Diff_Nbr, Etat_Sep, Etat_Opr,
Etat_Slash, Etat_Diff_Eol, Etat_Diff_Slash, Etat_Ligne_Comn,
Etat_Mul_Lignes_Comm, Etat_Chaine, Etat_Fin_Chaine, Etat_Erreur.
Symboles :
Sym_EOL, Sym_Blanc, Sym_Lettre, Sym_Chiffre, Sym_Sep, Sym_Opr, Sym_Slash,
Sym_Apostrophe, Sym_Autre.
Ensemble des symboles :
 Slash = [''];
 EOL = [#0, #10, #13];
 Blancs = [#0..#32];
 Lettres = ['A'..'Z', 'a'..'z', '_', '‫;]'ي'..'أ‬
 Chiffres = ['0'..'9'];
 Apostrophe = '"';
 Constantes = Chiffres + [Apostrophe];
 Separateurs = ['(', ')', '{', '}', '‫,'؛‬ '،', '.', ':'];
 Operateurs = ['+', '-', '*', '÷', '%', '=', '~', '#', '<', '>', '»', '«', '!', '&', '|'];
 Tous_Symboles = Slash + EOL + Blancs + Lettres + Chiffres + Separatateurs +
Operateurs;

16
Sym_Autre
Sym_Slash
Sym_Blanc
Sym_EOL
Sym_Opr
Sym_Sep
Sym_
Apostrophe
Sym_Chiffre
Sym_Lettre
Etat
Symoble
Etat_Erreur
Etat_Slash
Etat_Initial
Etat_Initial
Etat_Opr
Etat_Sep
Etat_Chaine
Etat_Nbr
Etat_Ident
Etat_Initial
Etat_Diff_
Ident
Etat_Ident
Etat_Ident
Etat_Ident
Etat_Diff_
Nbr
Etat_Nbr
Etat_Erreur
Etat_Nbr
Etat_Chaine
Etat_Fin_
Chaine
Etat_Chaine
Etat_Diff_
Slash
Etat_Diff_Eol
Etat_Slash
Etat_Diff_
Slash
Etat_Mul_
Lignes_Comm
Etat_Diff_
Slash
Etat_Diff_
Eol
Etat_Ligne_
Comn
Etat_Diff_
Eol

17
La table de symboles
Est un tableau dynamique, tel que les premiers entrés de la table (43 entrés)
comprend les mots réservés, les séparateurs et les opérateurs, le reste est réservés aux
unités lexicale du programme source tel que: les identificateurs, les constantes, …
N° Nom Intituler Adresse Unité Type
01 Prog ‫ﺑﺮﻧﺎﻣﺞ‬ 0 Mot Réservé Vide
02 Conste ‫ﺛﺎﺑﺖ‬ 0 Mot Réservé Vide
03 Variable ‫ﻣﺘﻐﯿﺮ‬ 0 Mot Réservé Vide
04 Logic ‫ﻣﻨﻄﻘﻲ‬ 0 Mot Réservé Vide
05 Entier ‫ﺻﺤﯿﺢ‬ 0 Mot Réservé Vide
06 Naturel ‫ﻃﺒﯿﻌﻲ‬ 0 Mot Réservé Vide
07 Chaine ‫ﺳﻠﺴﻠﺔ‬ 0 Mot Réservé Vide
08 Carac ‫رﻣﺰ‬ 0 Mot Réservé Vide
09 Tant_que ‫ﺑﯿﻨﻤﺎ‬ 0 Mot Réservé Vide
10 Faire ‫ﻗﻢ‬ 0 Mot Réservé Vide
11 Si ‫اذا‬ 0 Mot Réservé Vide
12 Alors ‫ﻓﺎن‬ 0 Mot Réservé Vide
13 Si_non ‫واﻻ‬ 0 Mot Réservé Vide
14 Oui ‫ﻧﻌﻢ‬ 0 Mot Réservé Vide
15 Non ‫ﻻ‬ 0 Mot Réservé Vide
16 Lire ‫اﻗﺮا‬ 0 Mot Réservé Vide
17 Ecrire ‫اﻃﺒﻊ‬ 0 Mot Réservé Vide
18 Opr_Aff = 0 Opérateur Vide
19 Opr_Addi + 0 Opérateur Vide
20 Opr_Sous - 0 Opérateur Vide
21 Opr_Muli * 0 Opérateur Vide
22 Opr_Divi ÷ 0 Opérateur Vide
23 Opr_Modu % 0 Opérateur Vide
24 Opr_Egale ~ 0 Opérateur Vide
25 Opr_Diff # 0 Opérateur Vide
26 Opr_Infe > 0 Opérateur Vide
27 Opr_Supp < 0 Opérateur Vide
28 Opr_Infe_Egale » 0 Opérateur Vide
29 Opr_Supp_Egale « 0 Opérateur Vide
30 Opr_Ou | 0 Opérateur Vide
31 Opr_Et & 0 Opérateur Vide
32 Opr_Non ! 0 Opérateur Vide
33 Parent_Ferm ) 0 Séparateur Vide
34 Parent_Ouvr ( 0 Séparateur Vide
35 Accoulad_Ferm { 0 Séparateur Vide
36 Accoulad_Ouvr } 0 Séparateur Vide
37 Point . 0 Séparateur Vide
38 Virgule ، 0 Séparateur Vide
39 Point_Virgule ‫؛‬ 0 Séparateur Vide
40 Deux_Point : 0 Séparateur Vide
41 Anti_Slash 0 Séparateur Vide
42 Vide 0 Séparateur Vide

18
Chaîne de références
C'est un tableau dynamique qui représente la séquence ment des unités lexicale dans le
texte source, la chaîne est remplir au fur et à mesure du remplissage de la table de symboles.
Mémoires de stockage
Le tableau de symboles contient seulement les noms et les types et les adresses des unités
lexicale, les valeurs des variables et des fixes (constantes déclarées) sont sauvegarder dans 05
mémoires dynamiques, une mémoire pour chaque type de données (Entier, Naturel, Logique,
Caractère et Chaîne). Si on à déclarés 10 variables (par exemples), on à dix case allouées répartis
dans les mémoires de stockage.
Fonctionnement général du Khawarizmi
 Initialisation des différents paramètres.
 Récupération du code source à partir d'un fichier.
 Lancement du l'analyseur lexical.
 Remplissage de la table des symboles et la chaîne de références.
 Lancement de l'analyseur syntaxique et sémantique.
 Gestion des erreurs durant les différentes phases.
Fig. 11 fonctionnement générale du Khawarizmi.

19
L'analyse lexicale
 Initialisation.
 Si non fin de fichier initialiser le mot, le caractère et l'état courant.
o Si l'état des définit alors avancer, récupérer le nouveau état.
o Si non (état final) reconnue le mot courant.
 Si non terminer l'analyse.
Fig. 12 L'analyseur lexical.

20
Règles EBNF du Khawarizmi
Programme = " ‫ﺑﺮﻧﺎﻣﺞ‬ " Ident "‫"؛‬ Bloc ".".
Ident = Lettre {Lettre | Chiffre}.
Lettre = "A" | "B" | ... | "Z" | "a" | "b" | ... | "z" | "‫"ا‬ | "‫"ب‬ | … | "‫"ي‬ | "_".
Chiffre = "0" | "1" | ... | "9".
Bloc = [Partie_Declaration_Constantes]
[Partie_Declaration_Variables]
Bloc_Instructions.
Partie_Declaration_Constantes = "‫ﺛﺎﺑﺖ‬" Deffinition_Constante
{Deffinition_Constante}.
Deffinition_Constante = Ident "=" Constant "‫."؛‬
Const = [Opr_Signe] Nombre | Chaine | "‫"ﻧﻌﻢ‬ | "‫."ﻻ‬
Nombre = Chiffre {Chiffre}.
Chaine = "'" Carac {Carac} "'".
Carac = Carac_Qeul_Que_Soit_Sauf_Apostrophe | "''".
Partie_Declaration_Variables = " ‫ﻣﺘﻐﯿ‬‫ﺮ‬ " Deffinition_Variables
{Deffinition_Variables}.
Deffinition_Variables = Idents ":" Type "‫."؛‬
Idents = Ident {'،' Ident}.
Type = "‫ﺻﺤﯿﺢ‬ "| "‫ﻃﺒﯿﻌﻲ‬ " | "‫"ﻣﻨﻄﻘﻲ‬ | "‫رﻣﺰ‬ " | "‫"ﺳﻠﺴﻠﺔ‬ .
Bloc_Instructions = "}" Instructions "{".
Instructions = Instruction {"‫"؛‬ Instruction}.
Instruction = [Lecture | Ecriture | Affectation |
Instruction_Conditionelle | Instuction_Repetition].
Lecture = " ‫اﻗﺮا‬ " ")" Idents "(".
Ecriture = " ‫اﻃﺒﻊ‬ " ")" Idents "(".
Affectation = Ident "=" Expression.
Expression = Expression_Simple [Opr_Rel Expression_Simple].
Expression_Simple = [Opr_Signe] Terme {Opr_Add Terme}.

21
Opr_Signe = "+" | "-".
Terme = Facteur {Opr_Mul Facteur}.
Facteur = Ident | Const | ")" Expression "(" | "!" " Facteur | " ‫"ﻧﻌﻢ‬ | "‫."ﻻ‬
Opr_Mul = "*" | "÷" | "%" | "&".
Opr_Add = "+" | "-" | "|".
Opr_Rel = "<" | ">" | "»" | "«" | "~" | "#".
Instruction_Conditionelle = " ‫اذا‬ " Expression "‫"ﻓﺎن‬ Bloc_Instructions
["‫واﻻ‬ " Bloc_Instructions].
Instuction_Repetition = " ‫ﺑﯿﻨﻤﺎ‬ " Expression " ‫ﻗﻢ‬ " Bloc_Instructions.
Règles de la grammaire
Après la définition des règles EBNF de la grammaire du Khawarizmi, en doit les
transformer en des règles classique à fin de construire les ensembles premier et suivant.
Programme  " ‫ﺑﺮﻧﺎﻣﺞ‬ " Ident "‫"؛‬ Bloc ".".
Ident  Lettre Lett_Chiff.
Lett_Chiff  Lettre Lett_Chiff / Chiffre Lett_Chiff.
Lettre  "A" / "B" / ... / "Z" / "a" / "b" / ... / "z" / " ‫ا‬ " /... / " ‫ي‬ " / "_".
Chiffre "0" / "1" / ... / "9".
Bloc  Partie_Declaration_Constantes
Partie_Declaration_Variables
Bloc_Instructions.
Partie_Declaration_Constantes  "‫ﺛﺎﺑﺖ‬" Ident "=" Constant "‫"؛‬
Deffinition_Constante / ξ.
Deffinition_Constante  Ident "=" Constant "‫."؛‬
Constant  Opr_Signe Nombres / Chaine / "‫"ﻧﻌﻢ‬ / "‫."ﻻ‬
Nombres  Chiffre Nombres / Nombre.
Nombre  Chiffre Nombres / ξ.
Chaine  ' " ' Carac ' " '.
Carac  carac_qeul_que_soit_sauf_apostrophe / " '' " /

22
carac_qeul_que_soit_sauf_apostrophe Carac / " '' " carac/.
Partie_Declaration_Variables  " ‫ﻣﺘﻐﯿ‬‫ﺮ‬ " Idents ":" Type "‫"؛‬
Deffinition_Variables / ξ.
Deffinition_Variables Idents ":" Type "‫"؛‬ Deffinition_Variables / ξ.
Idents  Idents Ident/ ξ.
Type  " ‫"ﺻﺤﯿﺢ‬ / " ‫ﻃﺒﯿﻌﻲ‬ " / "‫ﻣﻨﻄﻘﻲ‬ " / " ‫رﻣﺰ‬ " / "‫ﺳﻠﺴﻠﺔ‬ ".
Bloc_Instructions  "}" Instructions "{".
Instructions  Instruction " ‫"؛‬ Instructions / ξ .
Instruction  Lecture / Ecriture / Affectation /
Instruction_Conditionelle/ Instuction_Repetition / ξ .
Lecture  " ‫اﻗﺮا‬ " ")" Idents "(".
Ecriture  " ‫اﻃﺒﻊ‬ " ")" Idents "(".
Affectation  Ident "=" Expression.
Expression  Expression_Simple Op_Exp.
Op_Exp Opr_Rel Expression_Simple / ξ .
Expression_Simple  Opr_Signe Terme Op_Term / ξ .
Opr_Signe  "+" / "-" / ξ .
Op_Term  Opr_Add Terme Op_Term / ξ .
Terme  Facteur Op_Fact .
Op_Fact  Opr_Mul Facteur Op_Fact / ξ .
Facteur  Ident / Constant / ")" Expression "(" / "!" " Facteur / "‫ﻧﻌﻢ‬ "/ "‫"ﻻ‬ .
Opr_Mul  "*" / "÷" / "%" / "&".
Opr_Add  "+" / "-" / "|".
Opr_Rel  "<" / ">" / "»" / "«" / "~" / "#".
Instruction_Conditionelle  " ‫ا‬‫ذا‬ " Expression "‫ﻓﺎن‬ " Bloc_Instructions
Instruction_Sinon .
Instruction_Sinon "‫"واﻻ‬ Bloc_Instructions / ξ.
Instuction_Repetition  " ‫ﺑﯿﻨﻤﺎ‬ " Expression "‫ﻗﻢ‬ " Bloc_Instructions.

23
Les ensembles premier et suivant
Voici les ensembles premier et suivant qui sont construits après l'application des règles
de construction de ces deux ensembles.
NON TERMINAL PREMIER SUIVANT
Programme " ‫ﺑﺮﻧﺎﻣﺞ‬ " #
Ident "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ".
"‫,"؛‬ '،', ":" , "(","=" , "‫ﻗﻢ‬ " ,
"<" , ">" , "»" , "«" , "~" ,
"#","+" , "-" , "|","*" , "÷" ,
"%" , "&".
Lett_Chiff "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ","0", "1", ..., "9".
"‫,"؛‬ '،', ":" , "(","=" , "‫ﻗﻢ‬ " ,
"<" , ">" , "»" , "«" , "~" ,
"#","+" , "-" , "|","*" , "÷" ,
"%" , "&".
Lettre "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ", "_".
"‫","؛‬A", "B", ..., "Z", "a",
"b", ..., "z", " ‫ا‬ ", "‫,...,"ب‬ " ‫ي‬
","0", "1", ..., "9".
Chiffre "0", "1", ..., "9". ‫,"؛‬ '،', "A", "B", ..., "Z", "a",
"b", ..., "z", " ‫ا‬ ", "‫,...,"ب‬ " ‫ي‬
","0", "1", ..., "9".
Bloc "‫ﺛﺎﺑﺖ‬ ", " ‫ﻣﺘﻐﯿ‬‫ﺮ‬ ", "}". ".".
Partie_Declaration_
Const
ξ, "‫ﺛﺎﺑﺖ‬ ". " ‫ﻣﺘﻐﯿ‬‫ﺮ‬ ", "}".
Const "0", "1", ..., "9". "‫"(","؛‬ , "‫ﻗﻢ‬ " , "<" , ">" , "»"
, "«" , "~" , "#","+" , "-" ,
"|","*" , "÷" , "%" , "&".
Nombres ξ, "0", "1", ..., "9". "‫"(","؛‬ , "‫ﻗﻢ‬ " , "<" , ">" , "»"
, "«" , "~" , "#","+" , "-" ,
"|","*" , "÷" , "%" , "&".
Nombre "0", "1", ..., "9". "‫,"؛‬ '،' .
Chaines ξ, " ' ", tous_car_sauf_apostrophe "‫"(","؛‬ , "‫ﻗﻢ‬ " , "<" , ">" , "»"
, "«" , "~" , "#","+" , "-" ,
"|","*" , "÷" , "%" , "&".
Chaine " ' ", tous_car_sauf_apostrophe "‫,"؛‬ '،' .
Carac " ' ", tous_car_sauf_apostrophe " ' " .
Partie_Declaration_
Varia
" ‫ﻣﺘﻐﯿ‬‫ﺮ‬ ". "}".
Deffinition_Variables ξ, "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬
", "‫,...,"ب‬ " ‫ي‬ ".
"}".
Idents "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ".
":" , "(".
Type " ‫","ﺻﺤﯿﺢ‬ ‫ﻃﺒﯿﻌﻲ‬ ", "‫ﻣﻨﻄﻘﻲ‬ ",
" ‫رﻣﺰ‬ ", "‫ﺳﻠﺴﻠﺔ‬ ".
"‫."؛‬
Bloc_Instructions "}". ".", "‫,"؛‬ "‫."واﻻ‬
Instructions "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ", "‫,"؛‬ " ‫اﻗﺮا‬ "," ‫اﻃﺒﻊ‬ ".
"{".
Instruction ξ, "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬
", "‫,...,"ب‬ " ‫ي‬ ", "‫,"؛‬ " ‫اﻗﺮا‬ "," ‫اﻃﺒﻊ‬ ".
"‫."؛‬

24
Lecture " ‫اﻗﺮا‬ ". "‫."؛‬
Ecriture " ‫اﻃﺒﻊ‬ ". "‫."؛‬
Affectation "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ".
"‫."؛‬
Expression ξ, "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬
", "‫,...,"ب‬ " ‫ي‬ ","0", "1", ..., "9" ,"+" ,
"-" ,"<" , ">" , "»" , "«" , "~" , "#", "!"
,"‫ﻧﻌﻢ‬ ", "‫."ﻻ‬
"‫,"؛‬ "‫ﻗﻢ‬ ", "(", "‫ﻓﺎن‬ ".
Op_Exp ξ,"<", ">", "»", "«", "~", "#". "‫,"؛‬ "‫ﻗﻢ‬ ", "(", "‫ﻓﺎن‬ ".
Expression_Simple ξ, "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬
", "‫,...,"ب‬ " ‫ي‬ ","0", "1", ..., "9","+", "-
", "!","‫ﻧﻌﻢ‬ ", "‫."ﻻ‬
"‫,"؛‬ "‫ﻗﻢ‬ ", "(", "‫ﻓﺎن‬ ", "<", ">",
"»", "«", "~", "#".
Opr_Signe ξ, "+", "-". "A", "B", ..., "Z", "a", "b", ...,
"z", " ‫ا‬ ", "‫,...,"ب‬ " ‫ي‬ ","0",
"1", ..., "9", "!","‫ﻧﻌﻢ‬ ", "‫."ﻻ‬
Op_Term ξ, "+", "-", "|". "‫,"؛‬ "‫ﻗﻢ‬ ", "(", "‫ﻓﺎن‬ ", "<", ">",
"»", "«", "~", "#".
Terme "A", "B", ..., "Z", "a", "b",..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ","0", "1", ..., "9", "!","‫ﻧﻌﻢ‬
", "‫."ﻻ‬
"‫,"؛‬ "‫ﻗﻢ‬ ", "(", "‫ﻓﺎن‬ ", "<", ">",
"»", "«", "~", "#","+", "-",
"|".
Op_Fact ξ, "*", "÷", "%", "&". "‫,"؛‬ "‫ﻗﻢ‬ ", "(", "‫ﻓﺎن‬ ", "<", ">",
"»", "«", "~", "#","+", "-",
"|".
Facteur "A", "B", ..., "Z", "a", "b", ..., "z", " ‫ا‬ ",
"‫,...,"ب‬ " ‫ي‬ ","0", "1", ..., "9", "!","‫ﻧﻌﻢ‬
", "‫."ﻻ‬
"‫,"؛‬ "‫ﻗﻢ‬ ", "(", "‫ﻓﺎن‬ ", "<", ">",
"»", "«", "~", "#","+", "-",
"|","*", "÷", "%", "&".
Opr_Mul "*", "÷", "%", "&". "A", "B", ..., "Z", "a", "b", ...,
"z", " ‫ا‬ ", "‫,...,"ب‬ " ‫ي‬ ","0",
"1", ..., "9",")", "!","‫ﻧﻌﻢ‬ ",
"‫."ﻻ‬
Opr_Add "+", "-", "|". "A", "B", ..., "Z", "a", "b", ...,
"z", " ‫ا‬ ", "‫,...,"ب‬ " ‫ي‬ ","0",
"1", ..., "9", "!","‫ﻧﻌﻢ‬ ", "‫."ﻻ‬
Opr_Rel "<", ">", "»", "«", "~", "#". "A", "B", ..., "Z", "a", "b", ...,
"z", " ‫ا‬ ", "‫,...,"ب‬ " ‫ي‬ ","0",
"1", ..., "9","+", "-", "!","‫ﻧﻌﻢ‬
", "‫."ﻻ‬
Instruction_
Conditionelle
" ‫اذا‬ ". "‫."؛‬
Instruction_Sinon ξ, "‫."واﻻ‬ "‫."؛‬
Instuction_Repetition " ‫ﺑﯿﻨﻤﺎ‬ " "‫."؛‬
Après avoir réaliser la grammaire et construire les ensembles premier et suivant, en voie que la
grammaire est:
 N'est pas récursive à gauche;
 est factorisé à gauche ;
Après l'exécution des différents testes sur notre compilateur, il nous semble que la grammaire est
non ambiguë, alors ont conclue que grammaire du Khawarizmi est LL(1).

25
Diagrammes syntaxiques
Après avoir définir la grammaire du Khawarizmi; voici les diagrammes syntaxique qui
permettent bien de comprendre la syntaxe du langage.
Programme = " ‫ﺑﺮﻧﺎﻣﺞ‬ " Ident "‫"؛‬ Bloc ".".
Ident = Lettre {Lettre | Chiffre}.
Nombre = Chiffre {Chiffre}.
Lettre = "A" | "B" | ... | "Z" | "a" | "b" | ... | "z" | "‫"ا‬ | "‫"ب‬ | … | "‫"ي‬ | "_".
Chiffre = "0" | "1" | ... | "9".

26
Bloc = [Partie_Declaration_Constantes]
[Partie_Declaration_Variables]
Bloc_Instructions.
Partie_Declaration_Constantes = "‫ﺛﺎﺑﺖ‬" Deffinition_Constante
{Deffinition_Constante}.
Deffinition_Constante = Ident "=" Constant "‫."؛‬
Constant = [Opr_Signe] Nombre | Chaine | "‫"ﻧﻌﻢ‬ | "‫."ﻻ‬
Chaine = "'" Carac {Carac} "'".

27
Carac = Carac_Qeul_Que_Soit_Sauf_Apostrophe | "''".
Partie_Declaration_Variables = " ‫ﻣﺘﻐﯿﺮ‬ " Deffinition_Variables
{Deffinition_Variables}.
Deffinition_Variables = Idents ":" Type "‫."؛‬
Idents = Ident {'،' Ident}.
Type = "‫ﺻﺤﯿﺢ‬ "| "‫ﻃﺒﯿﻌﻲ‬ " | "‫"ﻣﻨﻄﻘﻲ‬ | "‫رﻣﺰ‬ " | "‫"ﺳﻠﺴﻠﺔ‬ .
Bloc_Instructions = "}" Instructions "{".

28
Instructions = Instruction {"‫"؛‬ Instruction}.
Instruction = [Lecture | Ecriture | Affectation |
Instruction_Conditionelle | Instuction_Repetition].
Lecture = " ‫اﻗﺮا‬ " ")" Idents "(".
Ecriture = " ‫اﻃﺒﻊ‬ " ")" Idents "(".
Affectation = Ident "=" Expression.
Expression = Expression_Simple [Opr_Rel Expression_Simple].

29
Expression_Simple = [Opr_Signe] Terme {Opr_Add Terme}.
Opr_Signe = "+" | "-".
Terme = Facteur {Opr_Mul Facteur}.
Facteur = Ident | Const | ")" Expression "(" | "!" " Facteur | " ‫"ﻧﻌﻢ‬ | "‫."ﻻ‬
Opr_Mul = "*" | "÷" | "%" | "&".

30
Opr_Add = "+" | "-" | "|".
Opr_Rel = "<" | ">" | "»" | "«" | "~" | "#".
Opr_Rel
< ~»> « #
Instruction_Conditionelle = " ‫اذا‬ " Expression "‫"ﻓﺎن‬ Bloc_Instructions
["‫واﻻ‬ " Bloc_Instructions].
Instuction_Repetition = " ‫ﺑﯿﻨﻤﺎ‬ " Expression " ‫ﻗﻢ‬ " Bloc_Instructions.

31
Mise en œuvre de l'analyseur lexicale
 Elimination des blancs et des caractères de contrôles;
 Elimination des commentaires;
 Reconnaissance des mots réservés, des opérateurs, des séparateurs;
 Reconnaissance des identificateurs, constantes (nombre, chaines de caractères);
 Remplissage de la table des symboles et de la chaîne de références.
Mise en œuvre de l'analyseur syntaxique
Dans le cadre de ce mini projet, on a choisi la méthode d'analyse par la descente récursive
par ce qu'elle est simple à implémenter et qui consiste à crée des procédures correspondants aux
non terminaux de la grammaire.
Pour chaque non terminal, une procédure est associée. L'analyse est faite par des appels récursifs
aux procédures et avancement lors de la reconnaissance des terminaux.
L'arbre syntaxique est construit au fur et à mesure de l'analyseur. A la reconnaissance d'un
terminal; un nœud est crée, et une feuille est crée lors de la reconnaissance d'un terminal.
Mise en œuvre de l'analyseur sémantique
L'analyse sémantique est faite en parallèle avec l'analyse syntaxique, elle comprend:
 Déclaration des constantes et des variables;
 Contrôle et conversion de types;
 Affectation des types et des valeurs;
 Evaluation des expressions;
 Mise à jour de la table de symboles;
 Gestion des erreurs, …
Gestion des erreurs
Est une tâche qui associée à tous les phases de la compilation, les différents erreurs sont:
Erreurs Lexicales
o Pas de texte source: lorsqu'on dispose du texte source (vide).
o Caractère illégal: lorsqu'un caractère n'appartient pas au jeu de caractères est détecté.
o Identificateurs erroné: lorsque le lexique de l'écriture d'un identificateur n'est pas respecté.
o Identificateurs trop long: lorsque la taille du mot dépasse 64 caractères.
Erreurs Syntaxiques
o Symbole attendu mais un autre est trouvé: Ex. Identificateur attendu mais nombre trouvé.
Erreurs Sémantiques
o Type attendu mais un autre est trouvé: Ex. type entier attendu mais naturel est trouvé.
o Opération interdit : Ex. l'opération de soustraction est interdit sur les types chaînes.
o Division par zéro.

32
IHM
C'est l'interface entre l'être humain et le compilateur, l'interface de l'application est
enrichie par des menus, boites de dialogue, zones de texte, listes, barres d'outils et d'état, …
 Ouverture et sauvegarde des fichiers à l'aide des boites de dialogue;
 Coloration syntaxique des mots réservés;
 Affichages des données (Table de symboles, chaîne de référence, arbre syntaxique, …);
 Insertion rapide des mots réservés, opérateurs, séparateurs et les caractères ASCII;
 Gestion des erreurs (nature, erreur, ligne, colonne, correction);
 Consultation et enregistrement des erreurs;
 Commandes standard (Couper, Copier, Coller, Impression, Recherche, …);
 Extension particulier (.khw) aux fichiers source et association avec l'application;
 Icônes particuliers aux fichiers *.khw et à l'application;
 Menus, raccourcis clavier, aide, images, …
 Inclusion du Rapport, Présentation, Code source à l'application;
Outil de développement
L'outil utilisé pour le développement du Khwarizmi est Borland Delphi 7.
Borland Delphi est un environnement de programmation visuelle orienté objet permettant de
développer des applications 32 bits en vue de leur deployment sous Windows et sous Linux.
Avec Delphi, vous pouvez créer de puissantes applications avec un minimum de programmation.
Delphi propose un ensemble d’outils de conception pour le développement rapide d’applications
(RAD), dont des experts programmateur et des modèles d’applications ou de fiches, et gère la
programmation orientée objet avec La bibliothèque de classes VCL pour Windows et CLX pour
Windows et Linux. [11]
Structure générale de l'application
Le schéma suivant montre les unités et fichiers de notre application (10 fichiers).
Fig. 13 Structure générale de l'application

33
Problèmes rencontrés
Durant la réalisation du compilateur, plusieurs problèmes ont été apparus, certains
problèmes ont été résolus :
 Enregistrement des valeurs: par ce que les valeurs associées aux variables et aux constantes
ont des types différents, il est impossible de les sauvegarder dans la table de symboles,
la solution est d'utiliser des mémoires de stockages (une mémoire pour chaque type).
 Le clavier arabe ne support pas quelques caractères, la solution est utiliser des insertions
rapide à l'aide du menu ou de la liste des codes ASCII, ainsi que l'utilisation des raccourcis.
 Les caractères Unicodes ne sont pas supportables par les composants standards du Delphi
tel que ≤, ≥, ≠, ≈, la solution est d'utiliser des composants tels que la suite des composants
TNT Delphi UNICODE Controls Project ou TMS Unicode Component Pack.
 L'utilisation de lettres arabes et latines dans la même ligne cause un problème à cause de
l'orientation du texte (gauche ou droite), la solution est d'utiliser les lettres arabes seulement.
 En à deux types de constantes : des constantes déclarées et non déclarées, la solution est de
nommée les constantes déclarées par des fixes.
 La déclaration des fixes (constantes) cause une double entrée dans la table de symboles et
dans les mémoires de stockages (gaspillage de mémoire), une entrée lors de la
reconnaissance de constantes (analyse lexicale), l'autre dans l'affection du type et de la valeur
(analyse sémantique).
 Les erreurs syntaxiques et sémantiques n'ont pas de rapport avec la ligne et la colonne de
l'éditeur, car la relation est avec la chaîne de référence seulement.
Historique du Khawarizmi
Date Version Tâche
02-12-06 Automate union.
23-12-06 0.030 Analyse lexicale:
 Table de transitions
 Tables de symboles.
 Chaine de références.
 Erreurs lexicales.
16-01-07 Grammaire du Khawarizmi
28-03-07 0.050 Analyse syntaxique:
 Procédures de la descente récursive.
04-04-07 0.060 Arbre syntaxique.
08-05-07 0.080 Analyse sémantique:
 Déclaration des variables et des constantes.
 Affectation des valeurs.
 Contrôle et conversion des types.
 Evaluation des expressions.
 Mise à jour de la table de symboles.

Compilateur KhawarizmiConclusion
34
Conclusion
La réalisation du compilateur du mini langage nous a aidés à comprendre et
à appliquer les différents techniques et méthodes d’analyse, de la compilation et de
la programmation.
On a remarqué clairement durant la réalisation du mini projet la complexité
et la complication de différentes techniques de compilation, parce qu'il s'agit du
traitement et d'analyse automatique des textes.
L'utilisation des outils tel que lex, yacc et plusieurs d'autres peut faciliter la
tâche aux programmeurs, surtout dans la phase d'analyse.
Les techniques de compilation sont utiles non seulement pour les
compilateurs, mais aussi peut servir à des taches importants tel que la traduction
entre les langes, la vérification grammatical et orthographiques des textes, la
conversion des codes source entre langages de programmation (C en JAVA), la
transformation des formats de fichier (HTML en latex)…
Le choix de la langue arabe à pour but d’encourager des informaticiens à
exploité cette langue dans leurs systèmes d’information.
En fin, en remercie infiniment notre enseignent chargé de cours monsieur
ALLAOUI Taher pour son support, son aide et son sollicitude.

Compilateur KhawarizmiBibliographie
35
Bibliographie
1. Histoire de l'informatique, URL : http://histoire.info.online.fr/prog.html
2. Dictionnaire de l'informatique et l'Internet, Micro Application 1997.
3. Comment ça marche http://www.commentcamarche/langages/programme.htm
4. Compilateur, Encyclopédie Wikipedia, Décembre 2005.
URL : http://fr.wikipedia.org/wiki/Compilateur
5. Construction d'un Petit Compilateur de Pascal. Interpréteur
URL : http://www2.lifl.fr/pcp/pcp003.html
6. Forme de Backus-Naur, Encyclopédie Wikipedia, Décembre 2005.
URL : http://fr.wikipedia.org/wiki/Forme_de_Backus-Naur
7. EBNF, Encyclopédie Wikipedia, Décembre 2005.
URL : http://fr.wikipedia.org/wiki/EBNF
8. Concepts des langages informatiques, EBNF & Diagrammes syntaxiques.
9. Compiler Construction, Niklaus Wirth, Zürich, November 2005.
10. The programming Language PASCAL, Niklaus Wirth, Zürich, November 1972
URL : http://www.moorecad.com/standardpascal/Wirth-PascalRevisedReport.pdf
11. Guide du développeur, Borland Delphi 7 pour Windows.
12. Support de cours compilation, ALLAOUI Taher, 4éme
année informatique, Université de
Laghouat, 2006-2007.

Réalisation d'un compilateur de mini langage - Khawarizmi

Contenu connexe

Tendances

En vedette

Similaire à Réalisation d'un compilateur de mini langage - Khawarizmi

Plus de Bachir Benyammi

Dernier

Réalisation d'un compilateur de mini langage - Khawarizmi