Analyse LL

Théorie des langages formels - Partie II
Les langages algébriques.
Wadoud Bousdira1
wadoud.bousdira@univ-orleans.fr
1 LIFO,
University of Orléans
Orléans, France
Orléans, 2022
Analyse syntaxique LL(k)
1 Définition
2 Ensembles Premier et Suivant
3 Récursivité gauche
4 Factorisation
5 Grammaire LL(1)
6 Table d’analyse LL(1)
W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 2 / 49

Analyse syntaxique LL(k)
Dérivation gauche :
∗
S ⇒ a1 . . . aj |{z}
A α
| {z }
∈Σ ∈N
le mot à reconnaı̂tre est m,

il faut que m commence par a1 . . . aj
on doit dériver A et la grammaire comporte les règles
A → γ1 | γ2 | . . . | γn
Problème : rendre déterministe le choix entre γ1 , γ2 , . . . et γn .

Grammaire LL(k)
Grammaire LL(k)
où k est un entier fixé.
Si on sait quelle règle choisir à condition de regarder les k caractères qui
suivent (k caractères de prévision).
On étudiera les grammaires LL(1) : 1 caractère de prévision permet

de choisir quelle règle appliquer entre toutes les règles possibles
on tente de construire l’arbre de dérivation de façon descendante
I en ayant un parcours déterministe du mot de gauche à droite
I à condition de pouvoir regarder 1 caractère à l’avance.

Grammaire LL(1).
Exemple 1 :
S → aAS | b
A → a | bSA
mot : a3 b 2 ab
S ⇒g aAS ⇒g aaS ⇒g aaaAS ⇒g a3 bSAS ⇒g a3 bbAS ⇒g a3 b 2 aS ⇒g
a3 b 2 ab
Dans cette dérivation, on a besoin de connaı̂tre le prochain caractère et
seulement celui-ci (grammaire LL(1)).

Grammaire LL(1).
Exemple 2 :

 S → A|B
L = {an 1b n , n ≥ 0} ∪ {an 2b 2n , n ≥ 0}, P(L) = A → aAb | 1
B → aBbb | 2

L n’est pas LL(k), ∀k. Il suffit d’avoir n > k de a pour ne pas pouvoir
choisir entre S → A et S → B.

Ensembles Premier et Suivant d’une grammaire LL(1)
Premier(α)
soit un mot α ∈ (Σ ∪ N)∗
∗ ∗
Premier(α) = {x ∈ Σ / α ⇒ xβ} ∪ {, si α ⇒ }
Suivant(A)
soit A ∈ N ,
∗ ∗
Suivant(A) = {x ∈ Σ / S ⇒ αAxβ, α ∈ Σ∗ } ∪ {$, si S ⇒ αA, α ∈
Σ∗ }
ou encore
∗ ∗
[
Suivant(A) = Premier(γ) / S ⇒ αAγ ∪{$, si S ⇒ αA, α ∈ Σ∗ }
γ6=

Quel rôle ?
pour étudier les productions possibles à partir du non-terminal A :
A → γ1 | γ2 | . . . | γn
Ça marchera si on sait distinguer les γi en fonction des 1ers symboles qu’ils
produisent . . . Premier(γi ) d’où la notion de Premier.
Exemple 1 : S → aAS | b, A → a | bSA

Premier(aAS) = {a}, Premier(b) = {b} et {a} ∩ {b} = ∅
Premier(a) = {a}, Premier(bSA) = {b} et {a} ∩ {b} = ∅.

Exemple 2 : S → A | B, A → aAb | 1, B → aBbb | 2

Premier(A) = {a, 1},
{a, 1} ∩ {a, 2} =
6 ∅!
Premier(B) = {a, 2}
Exemple 3 : E → E + T | T , T → T ∗ F | F , F → n | x | (E )
Premier(E + T ) = Premier(E )
Premier(E ) = Premier(T ) = Premier(F ) = {n, x, (}

Grammaire LL(1).
Mais la notion de Premier ne suffit pas !
Exemple : S → aSa |
Premier(aSa) = {a}, Premier() = {}
Les ensembles sont disjoints et pourtant on ne sait pas choisir
lors de la reconnaissance de aaaa par ex :
S ⇒ aSa ⇒ aaSaa ⇒
Si on choisit S → aSa, on produit des ’a’ de trop !
si on choisit S → , on fait aussi apparaı̂tre un a qui était derrière S
d’où la notion de Suivant.
Quel est le problème ? a commence l’alternative aSa de S et
a ∈ Suivant(S) !
Si S → aSb | , et m = aabb,
S ⇒ aSb ⇒ aaSbb ⇒ aabb : dérivation déterministe.

Ensembles Premier et Suivant
Algorithmes de calcul
Pour calculer Premier :
∀ X ∈ (Σ ∪ N), appliquer les règles suivantes jusqu’à ce qu’aucun terminal
ni ne puisse être ajouté aux ensembles Premier
1 si X ∈ Σ, Premier(X ) = {X }
2 si X → ∈ P, ajouter à Premier(X )
3 si X ∈ N, et X → Y1 Y2 . . . Yk ∈ P,
I ajouter Premier(Y1 ) à Premier(X ),
I si ∈ Premier(Y1 ), ajouter Premier(Y2 ) à Premier(X ),
I ...
∗
I si ∈ Premier(Yj ), ∀j = 1, . . . , k (i.e. Y1 . . . Yk ⇒ ) alors ajouter
à Premier(X ).

Conséquence :
On étend la notion de Premier(X ), X ∈ (Σ ∪ N) à celle de
Premier(α), α ∈ (Σ ∪ N)∗
∀ la chaı̂ne X1 X2 . . . Xn ∈ (Σ ∪ N)∗ , Premier(X1 X2 . . . Xn ) se calcule
en ajoutant tous les symboles de Premier(X1 ) 6= .
Si ∈ Premier(X1 ), ajouter aussi les symboles de Premier(X2 ) 6= .
Si ∈ Premier(X1 ) et à Premier(X2 ), ajouter aussi les symboles de
Premier(X3 ) 6= .
etc . . .
Finalement, si ∀i, ∈ Premier(Xi ), ajouter à
Premier(X1 X2 . . . Xn ).

Pour calculer Suivant(A), ∀ A ∈ N :

Appliquer les règles suivantes jusqu’à ce qu’aucun terminal ne puisse être
ajouté aux ensembles Suivant :
1 mettre $ dans Suivant(S), où S est l’axiome et $ est un marqueur
droit indiquant la fin du texte en entrée.
$ 6∈ Σ (par hypothèse),
2 si A → αBβ ∈ P, ajouter Premier(β)\{} à Suivant(B).
3 si A → αB ∈ P
∗
ou A → αBβ ∈ P tq Premier(β) contient (i.e. β ⇒ ),
ajouter Suivant(A) à Suivant(B).
Remarque : n’est jamais dans un ensemble Suivant.

Exemple 1 : E → E + T | T , T → T ∗ F | F , F → x | n | (E )
Premier
x {x}
n {n}
(E ) {(}
F {x, n, (}
T, T ∗ F {x, n, (}
E, E + T {x, n, (}
Suivant
E {$, +, )}
T {$, +, ), ∗}
F {$, +, ), ∗}

Exemple 2 : S → AaAb | BbBa, A → , B →
Premier Suivant
AaAb {a} S {$}
BbBa {b} A {a, b}
S {a, b} B {b, a}
Exemple 3 : S → aSbS | bSaS |
Premier Suivant
aSbS {a} S {$, a, b}
bSaS {b}

S {a, b, }

Récursivité gauche.
Grammaire récursive à gauche

G est récursive à gauche si ∃ A ∈ N tq on peut construire une dérivation
+
de la forme A ⇒ Aα.
La récursivité gauche simple se caractérise par :
∃ A → Aα ∈ P

Récursivité gauche.
Pb de la récursivité gauche :
les méthodes d’analyse descendante ne peuvent pas fonctionner :
Si ∃ A → A α | β ∈ P et si on doit dériver A en une de ses
alternatives, Aα peut être choisie de façon répétitive sans aucun
moyen d’arrêt.
De +, dans ce cas, 1 caractère de prévision ne suffit pas à choisir
l’alternative à appliquer.
On prouvera + tard qu’une grammaire récursive à gauche ne peut pas être
LL(1).

Supprimer la récursivité gauche.
Comment supprimer la récursivité gauche ?

simple :
A → Aα | β où α, β ∈ (Σ ∪ N)∗ ne commencent pas par A.
On remplace A → Aα | β par :
A → βA0

A0 → αA0 |
générale : se ramener à une récursivité simple (par expansion de
non-terminaux) puis la supprimer.

Supprimer la récursivité gauche.
A A
A’
A
A
A’
A’
A
A’
β α α α α α β α α α α α ε

Exemple 1 :
E → T E0

E → E + T | T ⇐⇒
E 0 → +T E 0 |
Exemple 2 :
E → id E 0 | id (E ) E 0

E → id | id(E ) | E + id ⇐⇒
E 0 → +id E 0 |

Factorisation.
Grammaire non factorisée

Elle contient au moins 2 productions de la forme
A → α β1 | α β2 tq α ∈ (Σ ∪ N)+ .
Problème : le choix de l’alternative à appliquer devient impossible avec 1

caractère de prévision.

Factorisation.
On obtient une grammaire équivalente factorisée avec la méthode

suivante :
pour chaque A ∈ N, trouver le + long préfixe α commun à 2
alternatives ou +. Si α 6= :
A → α A0 | γ

A → α β1 | α β2 | . . . | α βn | γ ⇔
A0 → β1 | β2 | . . . | βn
où γ représente toutes les alternatives qui ne commencent pas par α

appliquer cette transformation de façon répétitive jusqu’à plus de
préfixe commun pour des alternatives.

Exemple
E → id E | (E , E ) | (E ) | id
équivalente à

 E → id A | (E B
A → E |
B → , E) | )


Grammaires LL(1).
Proposition :
une grammaire ambiguë n’est pas LL(1)
une grammaire récursive à gauche n’est pas LL(1)
une grammaire non factorisée n’est pas LL(1)

Grammaires LL(1).
Proposition :
une grammaire est LL(1) ssi ∀A → α | β ∈ P tq α 6= β,
1 Premier(α) ∩ Premier(β) = ∅
∗
2 si β ⇒ , Premier(α) ∩ Suivant(A) = ∅
∗ ∗
Conséquence : si β ⇒ , alors α ⇒
6 .
(1) et (2) permettent de tester si une grammaire est LL(1).

Exemple 1 :
E → E + T | T , T → T ∗ F | F , F → x | n | (E )
Récursive à gauche. On dérécursive :
(1) E → T E 0


 (2) E 0 → +T E 0 |



(3) T → F T 0
(4) T 0 → ∗F T 0 |




(5) F → x | n | (E )


Exemple 1
(2) : Premier(+T E 0 ) ∩ Premier() = {+} ∩ {} = ∅

Premier(+T E 0 ) ∩ Suivant(E 0 ) = {+} ∩ {$, )} = ∅
(4) : Premier(∗F T 0 ) ∩ Premier() = {∗} ∩ {} = ∅
Premier(∗F T 0 ) ∩ Suivant(T 0 ) = {∗} ∩ {$, ), +} = ∅
(5) : Premier(x) ∩ Premier(n) = ∅
Premier(x) ∩ Premier((E )) = ∅
Premier(n) ∩ Premier((E )) = ∅
Donc grammaire LL(1).

Exemple 2 : S → AaAb | BbBa, A → , B →
Premier(AaAb) ∩ Premier(BbBa) = {a} ∩ {b} = ∅
Exemple 3 : S → aSbS | bSaS |
1 Premier(aSbS) ∩ Premier(bSaS) = {a} ∩ {b} = ∅
2 Premier(aSbS) ∩ Premier() = {a} ∩ {} = ∅
3 Premier(bSaS) ∩ Premier() = {b} ∩ {} = ∅
4 Suivant(S) ∩ Premier(aSbS) = {$, b, a} ∩ {a} =
6 ∅!
Donc grammaire non LL(1).

Grammaires LL(1).
Que faire si la grammaire n’est pas LL(1) ?

dérécursiver les productions récursives à gauche ;
expanser : remplacer une occurrence d’un non-terminal par ses
productions ;
factoriser ;
itérer si nécessaire.
Remarque : Transformer la grammaire le − possible : les transformations
incorrectes modifient la sémantique d’une grammaire.

Exemple 4 :
I → LA | LB, A → , B → | BL | BC
L → a | b | . . . | z, C → 0 | 1 | . . . | 9
on expanse A dans les productions de I : I → L | LB
on factorise L : I → L I 0 , I 0 → | B
on dérécursive les productions de B :
B → B 0 , B 0 → LB 0 | CB 0 | ⇒ B → LB | CB |
On arrive à :
I → L I0


 I0 → | B



B → LB | CB |
L → a | b | ... | z




C → 0 | 1 | ... | 9


Exemple 4
On vérifie LL(1)
1 Premier() ∩ Premier(B) = {} ∩ (Premier(L) ∪
Premier(C ) ∪ {}) 6= ∅ !
On expanse B dans les productions de I 0 , i.e.
I 0 → | B ⇐⇒ I 0 → | LB | CB
On arrive à :
I → L I0


 I 0 → | LB | CB



L → a | b | ... | z
C → 0 | 1 | ... | 9




B → LB | CB |


Exemple 4
I 0 et B peuvent être confondus.
I → L I0



 0
 I →LB
 I → | LB | CB
 

B → | LB | CB

L → a | b | . . . | z ⇐⇒
L → a | b | ... | z
C → 0 | 1 | ... | 9

 

C → 0 | 1 | ... | 9

 
B → LB | CB |


Exemple 4
On vérifie LL(1)
1 Premier() ∩ Premier(LB) = {} ∩ Premier(L) = ∅
2 Premier() ∩ Premier(CB) = {} ∩ Premier(C ) = ∅
3 Premier(LB) ∩ Premier(CB) = ∅
4 Suivant(B) ∩ Premier(LB) = {$} ∩ {a, . . . , z} = ∅
5 Suivant(B) ∩ Premier(CB) = {$} ∩ {0, . . . , 9} = ∅
6 Premier(a) ∩ Premier(b) = ∅, Premier(a) ∩ Premier(c) = ∅ . . .
Premier(y ) ∩ Premier(z) = ∅
7 Premier(0) ∩ Premier(1) = ∅, Premier(0) ∩ Premier(2) = ∅ . . .
Premier(8) ∩ Premier(9) = ∅

Table d’analyse LL(1)
L’analyseur est un automate à pile déterministe sans état.

L’arrêt est sur pile vide
configuration initiale : (pile = S$, mot à analyser$) où S est le
sommet de pile et $ un symbole spécial
on construit une table M qui indique ce qu’il faut faire en fonction
du sommet de pile et du caractère de prévision dans le mot à
analyser. M est de la forme
Symbole ∈ Σ ∪ {$}
Symbole
∈N

4 actions possibles :
1 remplacer le sommet de pile par autre chose sans consommer de
symbole dans le mot (correspond à une action de dérivation gauche)
2 dépiler et avancer dans le mot d’un caractère si le sommet de pile et
le caractère de prévision sont identiques
3 échec : entrée de M vide
4 succès : fin de l’analyse.

Algorithme de construction de la table

Donnée : une grammaire G LL(1)
Résultat : une table d’analyse M de G
1 pour chaque production A → α de G, procéder aux étapes suivantes
I ∀ a ∈ Premier(α), ajouter α à M[A, a]

I si ∈ Premier(α), ajouter α à M[A, b], ∀ b ∈ Suivant(A).
2 faire de chaque entrée non définie de M une erreur.

Exemple 1 :
E → TE 0 , E 0 → +TE 0 | , T → FT 0 , T 0 → ∗FT 0 | , F → x | n | (E )
x n + ∗ ( ) $
E TE 0 TE 0 TE 0
E0 +TE 0
T FT 0 FT 0 FT 0
T0 ∗FT 0
F x n (E )

Exemple 1 : (suite)
Pile chaı̂ne d’entrée Action

E$ x ∗ (x + n)$ E → TE 0
TE 0 $ x ∗ (x + n)$ T → FT 0
FT 0 E 0 $ x ∗ (x + n)$ F →x
xT 0 E 0 $ x ∗ (x + n)$ dépiler et avancer
T 0E 0$ ∗(x + n)$ T 0 → ∗FT 0
∗FT 0 E 0 $ ∗(x + n)$ dépiler et avancer
FT 0 E 0 $ (x + n)$ F → (E )
(E )T 0 E 0 $ (x + n)$ dépiler et avancer

Exemple 1 : (suite)

E )T 0 E 0 $ x + n)$ E → TE 0
TE 0 )T 0 E 0 $ x + n)$ T → FT 0
FT 0 E 0 )T 0 E 0 $ x + n)$ F →x
xT 0 E 0 )T 0 E 0 $ x + n)$ dépiler et avancer
T 0 E 0 )T 0 E 0 $ +n)$ T0 →
E 0 )T 0 E 0 $ +n)$ E 0 → +TE 0
+TE 0 )T 0 E 0 $ +n)$ dépiler et avancer
TE 0 )T 0 E 0 $ n)$ T → FT 0

Exemple 1 : (suite)

FT 0 E 0 )T 0 E 0 $ n)$ F →n
nT 0 E 0 )T 0 E 0 $ n)$ dépiler et avancer
T 0 E 0 )T 0 E 0 $ )$ T0 →
E 0 )T 0 E 0 $ )$ E0 →
)T 0 E 0 $ )$ dépiler et avancer
T 0E 0$ $ T0 →
E 0$ $ E0 →
$ $ succès

Exemple 2 :
S → aaSbb | a |
LL(1) ?
Premier(aaSbb) ∩ Premier(a) = {a} =
6 ∅
On factorise :
S → aA |
A → aSbb |
Premier(aA) ∩ Premier() = ∅
Suivant(S) ∩ Premier(aA) = {$, b} ∩ {a} = ∅
Premier(aSbb) ∩ Premier() = ∅
Suivant(A) ∩ Premier(aSbb) = {$, b} ∩ {a} = ∅
=⇒ LL(1).

Exemple 2 : (suite)
S → aA | , A → aSbb |
a b $
S aA
A aSbb

Exemple 2 : (suite)
S → aA | , A → aSbb |

S$ aab$ S → aA
aA$ aab$ dépiler et avancer
A$ ab$ A → aSbb
aSbb$ ab$ dépiler et avancer
Sbb$ b$ S →
bb$ b$ dépiler et avancer
b$ $ échec !

Analyse LL
Un exemple d’application
On considère la grammaire G suivante :
G = ({a, b, c, d}, {S, E , F , G , H, C , D}, S, P)
où P est l’ensemble des règles suivantes :



 S → aE | bF



 F → aF | aG | aHD
G → Gc | d


 H → Ca
C → Hb




D → ab

G est-elle réduite ?

Prod = {D, G , F , S}


 S → bF
F → aF | aG


 G → Gc | d
D → ab


Acc = {S, F , G }

 S → bF
F → aF | aG
G → Gc | d

G 0 est-elle LL(1) ?

G0 :

 S → bF
aF 0

 F →


F0 → F |G
G → dG 0




 0
G → cG 0 |
Construire la table d’analyse LL(1) de G 0 .

a b c d $
S bF
F aF 0
F0 F G
G dG 0
G0 cG 0
Le mot baadc appartient-il à L(G 0 ) ?

Si oui, déduire de l’analyse du mot une dérivation gauche.

S$ baadc$ S → bF
bF $ baadc$ dépiler et avancer
F$ aadc$ F → aF 0
aF 0 $ aadc$ dépiler et avancer
F 0$ adc$ F0 → F
F$ adc$ F → aF 0
aF 0 $ adc$ dépiler et avancer
F 0$ dc$ F0 → G
G$ dc$ G → dG 0
dG 0 $ dc$ dépiler et avancer
G 0$ c$ G 0 → cG 0
cG 0 $ c$ dépiler et avancer
G 0$ $ G0 →
$ $ succès
dérivation gauche : 3ème colonne avec ⇒ au lieu de →.

Analyse LL

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Analyse LL

Transféré par

Droits d'auteur :

Formats disponibles

Théorie des langages formels - Partie II

Les langages algébriques.

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 2 / 49

le mot à reconnaı̂tre est m,

Problème : rendre déterministe le choix entre γ1 , γ2 , . . . et γn .

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 3 / 49

On étudiera les grammaires LL(1) : 1 caractère de prévision permet

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 4 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 5 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 6 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 7 / 49

Exemple 1 : S → aAS | b, A → a | bSA

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 8 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 9 / 49

Mais la notion de Premier ne suffit pas !

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 10 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 11 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 12 / 49

Pour calculer Suivant(A), ∀ A ∈ N :

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 13 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 14 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 15 / 49

Grammaire récursive à gauche

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 16 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 17 / 49

Comment supprimer la récursivité gauche ?

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 18 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 19 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 20 / 49

Grammaire non factorisée

Problème : le choix de l’alternative à appliquer devient impossible avec 1

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 21 / 49

On obtient une grammaire équivalente factorisée avec la méthode

où γ représente toutes les alternatives qui ne commencent pas par α

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 22 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 23 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 24 / 49

(1) et (2) permettent de tester si une grammaire est LL(1).

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 25 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 26 / 49

(2) : Premier(+T E 0 ) ∩ Premier() = {+} ∩ {} = ∅

Donc grammaire LL(1).

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 27 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 28 / 49

Que faire si la grammaire n’est pas LL(1) ?

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 29 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 30 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 31 / 49

I 0 et B peuvent être confondus.

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 32 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 33 / 49

L’analyseur est un automate à pile déterministe sans état.

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 34 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 35 / 49

Algorithme de construction de la table

I ∀ a ∈ Premier(α), ajouter α à M[A, a]

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 36 / 49

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 37 / 49

Pile chaı̂ne d’entrée Action

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 38 / 49

Pile chaı̂ne d’entrée Action

W. Bousdira (LIFO) Théorie des langages algébriques Orléans 2020 39 / 49

Pile chaı̂ne d’entrée Action

(2) : Premier(+T E 0 ) ∩ Premier() = {+} ∩ {} = ∅