IFT313 Introduction aux langages formels

IFT313

Introduction aux langages formels

Froduald Kabanza

Département d’informatique Université de Sherbrooke

planiart.usherbrooke.ca/kabanza/cours/ift313

Automates finis

Sujets couverts

• Automates finis.

• Reconnaître des tokens avec un automate fini.

IFT313 © Froduald Kabanza 3

Objectifs

• Être capable d’écrire une automate fini acceptant un langage donné.

• Être capable de programmer un automate fini reconnaissant les tokens d’un langage donné.

Références

[1] Sudkamp, T. A.. Languages and Machines. Third Edition Edition.

Addison-Wesley, 2005.

– Sections 5.1 à 5.5.

[2] Appel, A. and Palsberg. J. Modern Compiler Implementation in Java.

Second Edition. Cambridge, 2004.

– Sections 2.3

[3] Wolper, P. Introduction à la calculabilité, 3è édition. Dunod, 2006 – Sections 2.1 à 2.5

[4] Aho, A., Lam, M., Sethi R., Ullman J. Compilers: Principles, Techniques, and Tools, 2^nd Edition. Addison Wesley, 2007.

– Sections 3.6

IFT313 © Froduald Kabanza 5

Automates à états finis

Un automate à états finis, ou automate fini (AF) tout court, est un modèle très simpl e de programme ayant :

 une entrée de chaîne de symboles (caractères),

 un ensemble fini d’états,

 des transitions entre les états en fonction des symboles lus, et

 un état initial

un ensemble d’états accepteurs (appelés aussi états finaux).

if (rate >= 0) ……

Entrée

i f

IF

1 3 4

2 ...

w h

AF Tête de lecture

Définition formelle

Un automate fini M est un tuple M = (S,A,R,s0, F) : - A est un ensemble de symboles (l’alphabet) - S est un ensemble fini d’états

- R est soit:

+ Une relation de transition R : S × A* ® 2^S

pour les automate fini non déterministe (AFN) + Une fonction de transition R : S × A ® S

pour les automates finis déterministes (AFD) - s₀ est l’état initial (appartenant dans S)

- F est un ensemble finaux d’états (appartenant dans S)

IFT313 © Froduald Kabanza 7

Langage accepté par un automate

- La trace d’exécution d’un automate est la séquence d’états qu’il traverse en lisant son entrée.

- Un automate accepte son entrée s’il existe une exécution telle que l’automa te génère une trace terminant par un état accepteur et toute l’entrée est lu.

- Pour un automate non déterministe il y a plusieurs exécution potentielles:

 Un tel automate accepte son entrée si une telle exécutions terminant pa r un état accepteur et toute l’entrée est lu.

- Le langage accepté par un automate est l’ensemble des mots acceptés par l’

automates.

Exemples

1 2

[a-z]

[a-z]

[0-9]

ID :

REAL : 1 3

4 [0-9] 2

[0-9]

[0-9]

[0-9]

.

.

NUM : 1 [0-9] 2 [0-9]

IFT313 © Froduald Kabanza 9

Exemples

1 4

/ \n

Commentaires,

espaces, \n, \t : _{2 3}

/

[a-z]

“ “ ^{, \n, \t} 5

“ “ ^{, \n, \t}

Exemple : automate combiné

i f

ID

1 2 3

IF

[0-9a-z] 4 ID [a-eg-z0-9]

[0-9a-z]

/

\n 9

10 /

Comments Error

[a-z]

12

“ “, \n, \t

“ “, \n, \t

white space 13

5 6

[0-9]

REAL

[0-9]

Error other

7

8 [0-9]

[0-9]

NUM .

. [0-9]

[a-hj-z]

IFT313 © Froduald Kabanza 11

Implémenter un AFD

- AFD = Automate fini déterministe

- La composante principale d’un AFD est sa fonction de transiti on.

- Elle est facilement implémentée par un tableau à deux dimensi ons indexé par les états (des nombres) et l’alphabet.

- Par exemple si on met les états en lignes et l’alphabet en colon ne

trans[s][a]

est l’état successeur de s sous la transition a

Exemple

a..z 0..9 . ^{“ ”}

1 2 3 4 5

0 0 0 0 0

0 0 0 0 0 5 0

0 0 5 4

3 0 0 0 2 2

3 3 0

1 3

4

[0-9]

2

[0-9]

[0-9]

.

.

REAL NUM

[0-9]

5 “ ”

“ ”

SPACE

IFT313 © Froduald Kabanza 13

Implémenter un AFD

- En pratique l’AFD sera calculé par un générateur d’analyseur lexical tel qu e JFLEX, à partir d’un ensemble d’expressions régulières, du genre :

(“ ”)+ { /* ignore */}

[0-9]+ {return new Token(…);}

([0-9]+ “.”[0-9]*) | (“.”[0-9]+) {return new Token(…);}

Implémenter un AFD

- L’automate global est une combinaison des automates individuels

1 2

SPACE

“ ” “ ”

(“ ”)+

1 2

NUM

[0-9] [0-9]

[0-9]+

1 3

4 [0-9] 2

[0-9]

[0-9]

.

.

REAL [0-9]

([0-9]+ “.”[0-9]*) | (“.”[0-9]+)

IFT313 © Froduald Kabanza 15

Simuler un AFD

Algorithme I : DFASimualtor (Simulateur d’AFD ou PiloteAFD) - Entrée :

+ Chaîne de symboles input terminée par EOF (fin de fichier).

+ AFD D, avec la matrice de transitions trans, état initial s0 (in itialState), et états accepteurs F

- Sortie : True if D accepts x; False otherwise.

- Approche :

+ Suivre la fonction de transition trans.

+ Utiliser input.nextChar() pour lire la prochaine caractère dan

s input.

Code de l’algorithme

currentState = D.initialState;

currentInputPosition = 0;

currentChar = input.nextChar();

currentInputPosition++;

while ((currentChar!=EOF) && (currentState !=0 ) ) {

currentState = D.trans[currentState][currentChar];

currentChar = input.nextChar();

currentInputPosition++;

}

if in(currentState, D.F) && (currentChar == EOF)) return TRUE;

else return FALSE;

Exemple de trace

Entrée : 9 7 . 5 EOF

Retourne TRUE (accepte l’entrée) parce qu’il termine dans un état ac- cepteur et toute l’entrée est lue.

current State current

Input Position

0 1

2 2

3 3

4 3

1 2

1 3

4 [0-9] 2

[0-9]

[0-9]

.

.

REAL NUM

[0-9]

5

“ ”

“ ”

SPACE

‘ ‘ [0-9] ‘.’

1 ^{5 2 4}

2 ^{0 2 3}

3 ^{0 3 0}

4 ^{0 3 0}

5 ^{5 0 0}

IFT313 © Froduald Kabanza 17

Reconnaître des tokens

- L’algorithme précédent accepte ou rejette un chaîne de caractères.

- La tâche d’un analyseur lexical n’est pas juste d’accepter ou rejeter des cha înes de caractères.

- Il doit trouver la plus longue sous-chaîne de l’entrée correspondant à une e xpression régulière (longest match).

- On peut étendre l’algorithme précédent pour garder une trace de la plus lon gue sous-chaîne acceptée, en introduisant des variables additionnelles.

IFT313 © Froduald Kabanza 19

Reconnaître des tokens

- Garder une trace de la plus longue sous-chaîne acceptée revient à mémoris er la dernier état accepteur visité par l’AFD.

- Cela est fait en introduisant les variables suivantes :

+ initialInputPosition : position initiale de la tête de lecture;

+ LastFinal : Plus récent état accepteur visité;

+ inputPositionAtLastFinal : position dans la chaîne d’entrée lorsque l’

AFD était dans cet état.

+ text : sous-chaîne entre

+ initialInputPosition (left) et

+ inputPositionAtLastFinal (right).

C’est le texte du token.

- La plus longue sous-chaîne acceptée (longuest match), c-à-d., le token est reconnu, lorsque l’AFD atteint un cul-de-sac (c-à-d., état 0)

Reconnaître des tokens

- Chaque fois qu’un token est reconnu, l’AFD recommence dans son état init ial pour reconnaître le prochain token.

- En général, lorsqu’un token est reconnu, currentInputPosition peut être au- delà de inputPositionAtLastFinal.

 Il faut donc réinitialiser currentInputPosition

- En plus, il faut spécifier une table d’actions à effectuer dans les états accept eurs lorsqu’un token est reconnu.

 Ces actions sont du code Java.

 Action[d] donne le code pour l’état d.

IFT313 © Froduald Kabanza 21

Exemple

a..z 0..9 . ^{“ ”}

1 2 3 4 5

0 0 0 0 0

0 0 0 0 0 5 0

0 0 5 4

3 0 0 0 2 2

3 3 0

1 3

4

[0-9]

2

[0-9]

[0-9]

.

.

REAL NUM

[0-9]

5 “ ”

“ ”

SPACE

Reconnaître des tokens

- Actions

A[1] = {/* ignore */}

A[2] = {return new Token(Token.NUM, text, left, right);}

A[3] = {return new Token (Token.REAL, text, left, right);}

1 3

4

[0-9]

2

[0-9]

[0-9]

.

.

REAL NUM

[0-9]

5 “ ”

“ ”

SPACE

IFT313 © Froduald Kabanza 23

Reconnaître des tokens

- Token est une classe Java.

Son constructeur accepte comme arguments :

* type NUM or REAL

* String text : texte du texte d’entrée correspondant au token.

* int left : position de début (initialInputPosition)

* int right : position de fin (inputPositionAtLastFinal)

Exemple

Input : 9 7 . 5 7 EOF

lastFinal State current

State current

Input Position

initialInput Position (left) inputPosition

AtLastFinal State (right)

0 2 3 4 1

1 2 3 3 2

5 0

0 2 3 3 2

3

0 2 3 4 1

4

0 0 0 0 0

0

Action

A[3]

1 3

4

[0-9] 2 [0-9] _[0-9]

.

.

REAL NUM

[0-9]

5 “ ”

“ ”

SPACE

0

ungetChar() => initialInputPosition = 4

IFT313 © Froduald Kabanza 25

Exemple (suite)

text = substring(start,end) = substring(4,5) = “ ”

lastFinal State current

State current

Input Position

initialInput Position (left) inputPosition

AtLastFinal State (right)

4 6 5

1 0 5

0 5 5

4 5 5

4 4 4

Action

A[5]

1 3

4

[0-9] 2 [0-9] _[0-9]

.

.

REAL NUM

[0-9]

5 “ ”

“ ”

SPACE

Input : 9 7 . 5 7 EOF

0

ungetChar() => InitialInputPosition = 5

text = substring(start,end) = substring(5,6) = 7

lastFinal State current

State current

Input Position

initialInput Position (left) inputPosition

AtLastFinal State (right)

5 6 6

1 0 2

0 2 2

5 6 6

5 5 5

Action

A[2]

Exemple (suite)

Input : 9 7 . 5 7 EOF

1 3

4

[0-9] 2

[0-9]

[0-9]

.

.

REAL NUM

[0-9]

5 “ ”

“ ”

SPACE

0

IFT313 © Froduald Kabanza 27

Résumé

- Un AFD est un outil opérationnel pour reconnaître des tokens.

 Pour cela, il faut reconnaître la plus longue sous-chaîne de l’entrée, acceptée p ar l’automate.

- Une partie du devoir 1 consiste à implémenter l’algorithme de reconnaissance de to kens par un AFD.

- Mais les AFD peuvent être complexes à spécifier.

- Les expressions régulières sont plus simples.

- Il nous faut une méthode pour traduire une expression régulière en un automate fin i.

- La suite du cours explique comment :

 Convertir une expression en un AFN

 Convertir un AFN en un AFD.

 Simuler un AFN pour reconnaître des tokens.