Vous êtes sur la page 1sur 6

Chapitre N°01 : Analyse lexicale:

L'analyse lexicale consiste à partir d'un programme qui est une suite de caractères séparés
par des blancs à :
• Spécifier les différentes entités (les mots) du langage, on parlera d'entités lexicales parmi ces
entités, on reconnaît :
➢ Les identificateurs.
➢ Les mots clés (Les mots réservés).
➢ Les constantes.
➢ Les séparateurs.
• Éliminer les blancs, ainsi que les commentaires.
• Codifier les différentes entités lexicales.
• Construire la table des informations.

Remarques :
• Les mots clés et les séparateurs représentent les données du programme à compiler. Les
identificateurs et les constantes sont donnés par l'utilisateur.
• Dans certains langages, les mots clés ne sont pas réservés, ils peuvent être utilisés comme
identificateurs.
• Certains langages n'acceptent pas que les mots soient utilisés en temps qu'identificateurs, ils
sont alors directement insérés dans la table des symboles.

Implémentation d'un analyseur lexical:


Les entités lexicales sont décrites à l'aide de grammaires régulières qui sont reconnues par des
automates déterministes à états finis

Rappel :
Grammaire régulière à droite :
Soit G = <T, N,S,P> où :
T: ensemble de terminaux de la grammaire.
N: ensemble de non-terminaux.
S: axiome de la grammaire.
P: ensemble des règles de productions.
On dit qu'une grammaire est régulière droite si toutes les productions sont de la forme :
A aB /b a ∈T , b∈T , et A , B∈N .
∗ ∗

Grammaire régulière à gauche :


∗ ∗
Toutes les productions sont de la forme : A  Ba/b a∈T ,b ∈T , et A , B∈N .

Automate :
Soit A = <T,N,S,F,I>, Où:
T: ensemble de terminaux.
N: ensemble des états de l'automate.
S: l'état initial.
F: ensemble des états finaux.
I: ensemble des transitions.

-1- OpenMindStudents.org 2009


On appelle automate d'états finis, un système qui fait correspondre à une entité (Chaine
appartenant à T*), une réponse qui peut prendre l'une des valeurs, '' vrai '' ou '' faux ''.
I S i , a i =S j S i , S j ∈N , a i ∈T
I S i , =S i ∀ S i ∈N

Définition :

Le langage généré par l'automate A est noté L(A) tel que: L  A={w / S 0 
w
S k ; S k ∈F }

Exemple:
Construire un automate simple déterministe engendrant le langage formé d'une suite de ''0''
et ''1'' et n'ayant pas deux ''0'' consécutifs.
1
0
S0 A
1
A = < {0,1},{S0, A} , S0 , {S0,A} , I>
I(S0,1) = S0
I (S0, 0) = A

Correspondance entre automate et grammaire :

1. Passage d'une grammaire régulière droite à un automate :


On considère une grammaire régulière droite G =<T,N,S,P> et automate d'états finis
A =< T',N',S',F,I> où : T': ensemble de terminaux de l'automate T' =T.
N': ensemble des états de l'automate N ' = N ∪{ S f } .
S: l'état initial S' =S.
F: ensemble des états finaux F ={ S f } .
I: ensemble des transitions.
Si A aB alors I  A , a =B ∀ A , B∈N et a∈T .
Si A a alors I  A , a =S f ∀ A∈ N et a ∈T .

2. Passage d'un automate à une grammaire régulière droite:


Soit A =< T',N',S',F,I> un automate et G =<T,N,S,P> une grammaire régulière droite, nous
avons alors :
S'=S
T'=T
N ' = N ∪{ S f }
F ={ S f }

Si I  S i , a j =S k avec S k ∉F alors S i a i S k


Si I  S i , a j =S k avec S k ∈ F alors S i a j

-2- OpenMindStudents.org 2009


3. Passage d'une grammaire régulière à gauche à un automate :
Soient une grammaire à gauche G =<T,N,S,P> et A =< T',N',S',F,I> un automate, alors T'=T.
Lors de la construction de l'automate à partir d'une grammaire régulière gauche. L'axiome de
la grammaire devient l'état final, donc F ={S}, on crée donc un état initial, d'où
N ' = N ∪{ S ' }
I:
{
Si S i  a j Alors I S ' , a j =S i
Si S i  S k a j Alors I S k , a j =S i

Exemple:

{ {
S  S 0 0/ S 1 1 G=< T , N , S , P
P : S 0  S 1/1 T ={ 0,1}
S 1  S 0/0 N ={ S , S 0, S 1 }

S : axiome de la grammaire.
A : <T', N', S', F, I>
T' = {0,1}
N' = {S, S0, S1, S'}
S':état initial.
F' : {S} 0
1
S0 Sf
S' 1

1
0
0
S1

• Construction d'un automate déterministe à partir d'un automate non-déterministe :


Soit l'automate :

S1
S1 1/0
ℇ 0 Élimination
S0 1
1 0
S0 S2
Des ℇ-transitions
1 S2

-3- OpenMindStudents.org 2009


• Construction de la matrice de transition:
0
0 1 S0 S1
S0 S1 S1,S2 0
S1 - S1,S2 1
1
S1,S2 S1 S1,S2 S1,S2

• Représentation d'un automate en mémoire:


➢ On représente un AEF par une matrice de transition T. Une ligne pour chaque état de
l'AEF, une colonne pour chaque caractère (terminal de l'automate).
➢ Une constante pour l'état initial.
➢ Un vecteur des états finaux.

Exemple:

0 1
S' S1 S0
S0 S -
S1 - S
S S1 S0

• Algorithme de reconnaissance d'une entité lexicale:


En entrée, nous disposons d'une entité lexicale, nous utilisons l'automate afin de vérifier si
elle appartient au langage ou pas.

Début
Lire (entité) ;
Tc := 1er caractère de l'entité ;
Ec:= état initial;
Tant que ( Ec≠∅ ) et ( ¬Fin entité )
Faire
Ec := T[Ec, Tc] ;
Tc := Tc +1 ;
Fait;
Si Ec=∅ Alors Erreur : entité incorrecte ;
Sinon Si Ec∉F Alors Erreur : entité incorrecte;
Sinon '' entité correcte '' ;
codifier l'entité ;
Insérer l'entité dans la table des symboles;
Fsi;
Fsi;
Fin.

-4- OpenMindStudents.org 2009


Exercice :
1. Donner une grammaire régulière à gauche engendrant le langage formé de a et b,
mais contenant au moins 2a et 2b consécutifs.
2. Déduire l'AEF déterministe correspondant.
3. Analyser les chaines <abaa#> , <baba#>.

Grammaire régulière gauche :

{
S 0 S 0 a/ S 0 b /S 1 a/ S 2 b
S 1  S 2a / a
S 2  S 1 b /b

Déroulement :
S 0 S 1 a S 2 aa
S 1 baa S 2 abaa
S 1 babaa
 ababaa

Automate :
a a/b
a S1

S0
S'
a b

b b
S2

Matrice de transition:

a b
S' S1 S2
S0 S0 S0
S1 S0 S2
S2 S1 S0

-5- OpenMindStudents.org 2009


Algorithme de reconnaissance :

Début
Lire (chaine);
Tc := 1er caractère de la chaine ;
Ec := S' ;
Tant que ( Ec≠∅ ) et ( Tc≠# )
Faire
Ec := T[Ec, Tc] ;
Tc := Tc +1 ;
Fait;
Si Ec=∅ Alors Erreur : chaine incorrecte ;
Sinon Si Ec≠S 0 Alors Erreur ;
Sinon '' chaine correcte '' ;
codifier la chaine ;
Insérer la chaine dans la table des symboles;
Fsi;
Fsi;
Fin.

Analyse de la chaine :

Ec Tc Chaine Action
S' a abaa# Avancer
S1 b baa# Avancer
S2 a aa# Avancer
S1 a a# Avancer
S0 # # Avancer : - Chaine correcte
- codifier
- insérer
S' b baba# Avancer
S2 a aba# Avancer
S1 b ba# Avancer
S2 a a# Avancer
S1 # # Chaine incorrecte

-6- OpenMindStudents.org 2009