Vocabulaire terminal vt
This presentation is the property of its rightful owner.
Sponsored Links
1 / 74

Vocabulaire Terminal Vt PowerPoint PPT Presentation


  • 60 Views
  • Uploaded on
  • Presentation posted in: General

Vocabulaire Terminal Vt.

Download Presentation

Vocabulaire Terminal Vt

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Vocabulaire terminal vt

Vocabulaire Terminal Vt

auto, break, case, const (C89), continue, default, do, else, enum (C89), extern, for, goto, if, inline (C99), register, restrict (C99), return, sizeof, static, struct, switch, typedef, union, void (C89), volatile (C89), while, signed (C89), unsigned, char, short, int, long, float, double, _Bool (C99), _Complex (C99), _Imaginary (C99)

2/ Peuvent être valués

1/ Les mots du langage

Un cheval, des chevaux.

Aimer…aimassions.

Entier: 12345 est un mot qui porte une valeur.

Toto est un identificateur qui porte un nom.

On peut avoir un vocabulaire terminal très réduit (juste les caractères, pas de valuation) ou très riche : (syntaxe complexe de construction-12e-23 ou 23 décrits par le même terminal; pareil pour les conjugaisons), sans que cela ne change le langage décrit. Ce qui n'est pas traité ici est simplement repoussé plus haut.


Vocabulaire non terminal vn

Vocabulaire non Terminal Vn

Les concepts du langage.

instruction_if

déclaration_de_sous_programme

Groupe Sujet

Adjectif qualificatif

Proposition subordonnée

Ce sont des concepts utiles pour décrire le langage

Peuvent être différents selon les descriptions, tout en décrivant le même langage.


Les r gles

L'ensemble des règles qui définissent les éléments de Vn en fonction des éléments de Vn+Vt.

Les règles

Phrase: Sujet Verbe Complément.

instruction_if: if ( expression ) instruction ;

expression: …

instruction : …

Terminal

Non Terminal


L axiome

L'axiome

  • Une règle particulière est l'entrée dans la grammaire.


Une grammaire

Une Grammaire

{Vt, Vn, Ax, R}

{Vt, Vn, Ax, R}

{Vt, Vn, Ax, R}

{Vt, Vn, Ax, R}

{Vt, Vn, Ax, R}

Vocabulaire terminal (typiquement autour de 100 mots)

Vocabulaire non-terminal (pareil)

Le nom d'une règle: Program par exemple.

L'ensemble des règles qui définissent Vn en fonction de Vn et Vt. Plusieurs dizaines de pages.


Finitudes

Finitudes

Un langage est (en général) infini.

Il peut être décrit par une infinité de grammaires qui le décrivent chacune totalement

Donc chacune est finie.


D rivation r duction

Dérivation/Réduction

Achille → héros au pied léger (πόδαςὠκὺςἈχιλλεύς)

Voici Achille!

Voici le héros au pied léger!

réduction

dérivation


Classification des grammaires

Classification des Grammaires

  • Type 4 – sans grand intérêt. Toutes les règles sous la forme A -> a

  • Type 3 – Toutes les règles peuvent être réécrites A -> aB ou A -> a. Pas de récursivité.

  • Type 2 – Toutes les règles sont de la forme A -> g(un seul Vn à gauche, récursivité possible).

  • Type 1 – Les règles peuvent être définies sous la forme aAb -> agb. Règle définie " en contexte ".

  • Type 0 – tout est permis, inutilisable en pratique.

Conventions ici

Majuscules (A B C): est un non-terminal

Minuscule (a b c): est un terminal

Grec (a b g): séquence de terminaux et non-terminaux

e: séquence vide


Type 3

Type 3

  • Toutes les règles peuvent être réécrites A -> aB ou A -> a (variante A-> Ba ou A-> a)

  • Exemple ENTIER → chiffre ENTIER ENTIER → chiffre

  • Analyse de 123:ENTIER (1ENTIER) 1(2ENTIER) 12(3)


Type 2

Type 2

Toutes les règles sont de la forme A -> g

  • Exemple: Entier palindrome

    • PALIND → 1 PALIND  1PALIND → 0 PALIND  0PALIND → e

Analyse de 101101:

PALIND

(1PALIND1)

1(0PALIND0)1

10(1PALIND1)01

101(e)101

101101


Type 1

Type 1

  • Les règles peuvent être définies sous la forme aAb -> agb

  • On voit que A est alors défini " en contexte " (peut être redéfini ailleurs dans un autre contexte)

  • Exemple: voir poly

  • Peu utilisable en pratique.


Exercices

Exercices

  • X → l'homme qui a vuX → l'homme qui a vu XTOTO → c'est X l'ours et qui n'a pas eu peur.L'axiome est TOTO. Quelles sont les phrases du langage? Quelle classe de grammaire?

  • Soit la grammaire :A → B yB → xB → εL'axiome est A, les mots sont x et y. Classe? Phrases?

  • Mêmes questions :A → B yB → x BB → ε

  • Mêmes questions :A → B y BB → x BB → ε


Exercice grammaire d expression

Exercice: grammaire d'expression

G = { Vt, Vn, Ax, R }

Vt = { + - * / ( ) entier}

Vn = { EXPRESSION TERME}

Ax = EXPRESSION

R = {

EXPRESSION → TERME '+' TERME EXPRESSION → TERME'-' TERME EXPRESSION → TERME '*' TERME EXPRESSION → TERME '/' TERME EXPRESSION  → TERME TERME → entierTERME  → '(' EXPRESSION ')'

}

Cette grammaire…

accepte-t-elle une expression comme 2+3?accepte-t-elle une expression comme 2+(3+4)?accepte-t-elle une expression comme 2+3+4 ?


Premier

Premier

  • Premier(règle): c'est l'ensemble des terminauxsusceptibles de commencerune des règles d'un non-terminal, dans toutes les phrases possibles du langage.

Si une règle dit A → x B: x est dans premier(A)

Si une règle dit A→ B y:

Premier(A) contient Premier(B)

Premier(A) contient y si e est un choix possible pour B

  • Transitivement: A→ BCDz

    • Premier(A) contient Premier(B)

    • Si e est un choix possible pour B, Premier(A) contient aussi Premier(C)

    • Si en plus e est un choix possible pour C, Premier(A) contient aussi Premier(D)

    • Si en plus e est un choix possible pour D, Premier(A) contient aussi z


Suivant

Suivant

  • Suivant(règle) est l'ensemble des mots du langage susceptibles d'apparaître à droite de X dans une dérivation possible de la grammaire.

  • Si une règle dit X -> a Y b, le contenu de SUIVANT(Y) est augmenté de PREMIER(b), sauf e le cas échéant.

  • Attention: X -> a Y Z b avec Z qui contient e va donner pour SUIVANT(Y) l'union de PREMIER(Z) et de PREMIER(b), sauf e.

  • Si une règle dit X -> a Y (ou équivalent, a Y b avec e dans PREMIER(b)), SUIVANT(Y) est augmenté de SUIVANT(X) puisque là où apparaîtra X peut apparaître a Y avec les mêmes suivants.


Exercices1

Exercices

Soit la grammaire dont l'axiome est A:

A → ε

A → B A a

B → b

B → ε

Construire les ensembles PREMIER et SUIVANT des non-terminaux.

Même question:

A → A B a C D

A → a

B → B b D

B → ε

C → c D

D → d

D → ε


Expressions r guli res type 3

Reconnaissance de aab ou abb

b

a

Départ

Succès

a

b

b

Si l'automate finit l'analyse dans un autre état que "Succès", la phrase n'a pas été reconnue.

Expressions régulières (type 3)

  • Notation

    • Séquence ab pour " a puis b inconditionnellement ".

    • Barre verticale a|b pour " ou "

    • Étoile a* postfixée pour " zéro fois ou plus "

    • Plus a+ postfixé pour " une fois ou plus "

    • Point d'interrogation a? postfixé pour " optionnel "

    • Usage des parenthèses

  • Exemple: a(a|b)b

  • Automate équivalent


Automate non d terministe

a

Départ

Succès

a

b

b

b

Automate non déterministe

  • (a|b)*abb

  • Accepte tout si ça se termine par abb

  • Automate équivalent non déterministe


Rendre d terministe quivalences

Sous-automate X

Sous-automate X

e

e

e

e

Début

Début

e

e

Sous-automate Y

e

Sous-automate Y

Sous-automate X

Début

Début

Début

x

e

e

e

Sous-automate X

Début

e

e

e

e

Sous-automate X

Début

e

e

Rendre déterministe - Équivalences

  • Terminaux et e

  • Séquence

  • Répétitions * et +

  • Choix et option


Exemple a b abb

3

2

a

e

e

e

e

Succès

10

Départ

0

8

9

1

6

7

e

a

b

b

e

e

e

4

5

b

Exemple (a|b)*abb

A : {0, 1, 2, 4, 7}.


Exemple suite

3

2

a

e

e

e

e

Succès

10

Départ

0

8

9

1

6

7

e

a

b

b

e

e

e

4

5

b

Exemple (suite)

Par transition a, direct

Puis par les e

A : {0, 1, 2, 4, 7}.

B: {0, 1, 2, 3, 4, 6, 7, 8}.


Exemple suite1

3

2

a

e

e

e

e

Succès

10

Départ

0

8

9

1

6

7

e

a

b

b

e

e

e

4

5

b

Exemple (suite)

A : {0, 1, 2, 4, 7} départ

B: {0, 1, 2, 3, 4, 6, 7, 8} venant de A par a

  • C: {0, 1, 2, 4, 5, 6, 7} venant de A par b

D: {0, 1, 2, 4, 5, 6, 7, 9} venant de B par b

E: {0, 1, 2, 4, 5, 6, 7, 10} venant de D par b

Les autres choix retombent sur A B C D E F


Exemple suite2

Exemple (suite)

A : {0, 1, 2, 4, 7} départ

B: {0, 1, 2, 3, 4, 6, 7, 8} venant de A par a

  • C: {0, 1, 2, 4, 5, 6, 7} venant de A par b

D: {0, 1, 2, 4, 5, 6, 7, 9} venant de B par b

E: {0, 1, 2, 4, 5, 6, 7, 10} venant de D par b

On complète

b

D

B

a

a

b

A

a

a

b

E

C

a

b

b


Exercice

Exercice

  • L'expression b*(a|b) ?a ne se recopie pas directement en automate déterministe. Utiliser la méthode pour le rendre déterministe.


Analyse descendante ll

Analyse Descendante LL

  • A -> a

  • L'analyse descendante va récursivement descendre dans toutes les règles de a et déterminer que A est reconnu si a est reconnu.

  • A lui-même peut-être une des règles examinées transitivement par une règle qui l'appelle.

  • La récursion à droite est possible.

  • À la fin, l'axiome est reconnu ou pas.


Notation

Notation

  • BNF: Backus-Naur Form et complications

    • Forme simple

      • Non-Terminal :: définition

      • Séquence signifie " et "

      • Duplication de la définition signifie " ou "

      • Possibilité de mettre " rien " pour e.

    • Forme plus agréable

      • Barre verticale pour " ou "

      • Parenthèses

    • Forme YACC

      • Un seul deux-points

      • Un point-virgule à la fin

R1 :: A x B C

R2 :: une_définition

R2 :: une_autre

R2::

R3 :: | une_définition | une_autre

rien

R4 ::(une_déf | une_autre_déf) encore_une

Non_Terminal : définition ;


M thode ll1 left to right leftmost derivation 1 lookahead

Méthode LL1 (Left to Right Leftmostderivation1 lookahead)

  • L'analyse revient à

    • Lire le premier jeton comme jeton courant

    • Reconnaître le non-terminal axiome

  • Reconnaissance d'un non-terminal

    • Un non-terminal est reconnu si une des séquences qui le définissent est reconnue.

  • Reconnaissance d'une séquence a

    • Soit a commence par un non-terminal B (a est de la forme B b) et a est reconnu si B est reconnu puis si b est reconnu.

    • Soit a commence par un terminal (a est de la forme ab) et a est reconnu si le " jeton " courant est a (on le consomme en passant au suivant), puis si b est reconnu.


Ll1 exemple

LL1 exemple

axiome → expr';'

expr → terme '+' terme

expr → terme '-' terme

expr → terme

terme → primaire '*' primaire

terme → primaire '/' primaire

terme → primaire

primaire → '(' expr')'

primaire → entier

entier → chiffre entier

entier → chiffre

chiffre → '0'

chiffre → '1'

etc…

chiffre → '9'


Analyse d un jeu de r gles

expr → terme '+' terme

expr → terme '-' terme

expr → terme

Ai-je un caractère de PREMIER(terme)?

Puis ai -je un terme ?

Non : Erreur

Ai-je un '+' ?

Ai-je un caractère de PREMIER(terme)?

Puis ai-je un terme ?

Non : échec

Ai-je un '-' ?

Ai-je un caractère de PREMIER(terme)?

Puis ai -je un terme ?

Non : Erreur

Ni '+' ni '-' ?

expr

Échec = la règle n'est pas reconnue mais il n'y a pas forcément d'erreur (autre branche possible plus haut à l'appel de la règle). return 0 ;

Erreur = la règle n'est pas reconnue et il n'y a pas d'autre solution (on a avancé dans la lecture). Irrécupérable.

exit(1)

Succès : la règle est reconnue.

return 1 ;

Analyse d'un jeu de règles


Criture d un automate quivalent en c

Écriture d'un automate équivalent en C

  • Chaque non_terminal devient une fonction C qui

    • Rend 1 si une règle a été reconnue

    • Rend 0 si aucune règle n'a été reconnue

    • Fait une erreur si la situation est irrécupérable

  • Il y a des méthodes de construction systématique de ces fonctions


Criture d un automate quivalent

Écriture d'un automate équivalent

Accepter un terminal, ici un char:

charchar_courant ;

/* global, initialisé dans main() */

inttok(char quoi) {

if (char_courant==quoi) {

char_courant = char_suivant() ;

/* à écrire avec getchar ou scanf*/

/* on lit le caractère suivant */

return 1 ;

} else return 0 ;

}

Accepter A puis B :

intA_puis_B () {

if (A()) {

if (B()) {

return 1;

}

else return 0;

/*(ou exit(1), si A a fait

lire un caractère */

}

else return 0 ;

}

Accepter A ou sinon B :

intA_ou_sinon_B () {

if (A()) {

return 1;

}

else if (B()) {

return 1;

}

else return 0 ;

}

Accepter A zéro fois ou plus :

intA_opt () {

while (A());

return 1 ;

}

Accepter A optionnel :

intA_opt () {

A();

return 1 ;

}

int main()

{

char_courant = char_suivant() ;

if (axiome()) printf("Ok\n") ;

elseprintf("Ko\n");

}


Exemple

intfin_expr() }

if (tok('+')) {

if (terme()) {

return 1;

}

else {printf("erreur\n");

exit(1);}

}

else if (tok('-')) {

if (terme()) {

return 1;

}

else {printf("erreur\n");

exit(1);}

}

else return 1;

}

intexpr() {

if (terme()) {

if (fin_expr())

return 1;

else return 0;

else return 0;

}

Exemple

intexpr() {

if (terme()) {

if (tok('+')) {

if (terme()) {

return 1;

}

else {printf("erreur\n");

exit(1);}

}

else if (tok('-')) {

if (terme()) {

return 1;

}

else {printf("erreur\n") ;

exit(1); }

}

else return 1;

}

else return 0 ;

}

expr → terme '+' terme

expr → terme '-' terme

expr → terme

expr → terme fin_expr

fin_expr → '+' terme

fin_expr → '-' terme

fin_expr→


La notation polonaise inverse

La notation polonaise inverse

Pile

2+3

2

3

+

2

3

5

Tirer

Pousser

(2+3)*4

2

3

+

4

20

4

5

3

2

*

2+3*4

2

3

4

+

12

14

2

3

4

*

Exercices

2+3*4+5

(2+3) * (4+5)

2+ (3*4+5)


Une pile

Une Pile

  • Primitives

    • Pousser(X)

    • Tirer

    • Sommet(utilisation X=Sommet;)

    • SommetTirer(utilisation X=SommetTirer;)

  • Facile à faire en C avec des macros

    #define GRAND 1000

    int Pile[GRAND]; intIxPile=-1;

    #define Pousser(X) {Pile[++IxPile]=(X);}

    #define Tirer {IxPile--;}

    #define Sommet (Pile[IxPile])

    #defineSommetTirer (Pile[IxPile--])

  • Ajouter les assert!

    #define Pousser(X) {assert((IxPile>=-1) && (IxPile<GRAND-1));Pile[++IxPile]=(X);}

    Etc…


Les actions sur la pile

Les actions sur la pile

Hypothèse et contrainte: quand on sort d'une règle, le sommet de pile contient la valeur pertinente du calcul demandé.

(initialiser tmp_int à 0 dans primaire)

Multiplier par 10 tmp_int

Additionner le chiffre

entier → chiffre entier

entier → chiffre

primaire → '(' expr ')'

primaire → entier

Pousser (tmp_int)

x=SommetTirer;

y=SommetTirer;

Pousser(y +/- x)

expr → terme '+' terme

expr → terme '-' terme

expr → terme

(pareil pour expr)

x=SommetTirer;

printf(" %d\n ",x);

axiome → expr ';'


Exemple1

Exemple

intexpr() {

if (terme()) {

if (tok('+')) {

if (terme()) {

return 1;

}

else {printf("erreur\n");

exit(1);}

}

else if (tok('-')) {

if (terme()) {

return 1;

}

else {printf("erreur\n") ;

exit(1); }

}

else return 1;

}

else return 0 ;

}

expr → terme '+' terme

expr → terme '-' terme

expr → terme

x=SommetTirer;

y=SommetTirer;

Pousser(y + x)

x=SommetTirer;

y=SommetTirer;

Pousser(y - x)

x=SommetTirer;

y=SommetTirer;

Pousser(y +/- x)


Analyse lr l eft to right r ightmost derivation

Analyse LRLeft to Right, Rightmostderivation

  • Une pile de terminaux et non-terminaux

  • Shift : On empile

  • Reduce: On remplace une séquence reconnue par le nom de la règle

  • Nécessité d'une compilation de la grammaire pour rendre l'automate déterministe : pas de programme simple équivalent à la grammaire.


Exemple 1

Exemple (1)

Analyse ascendante de 13+4

réduction

chiffre → '3'

réduction

entier → chiffre

réduction

chiffre → '1'

shift

shift

Pile

entier

chiffre

3

chiffre

chiffre

chiffre

chiffre

1

+

+

1

3

+

3


Exemple 2

Exemple (2)

réduction

chiffre → '4'

shift

réduction

entier → chiffre entier

réduction

primaire →entier

4

shift

chiffre

réduction

terme →primaire

+

+

+

entier

primaire

terme

terme

terme

terme

+

EOT

+

4

+

+


Exemple 3

Exemple (3)

réduction

expr →

terme '+' terme

réduction

terme →primaire

réduction

entier → chiffre

réduction

primaire →entier

shift

réduction succès

primaire

entier

terme

EOT

+

+

+

expr

expr

terme

terme

terme

EOT

EOT

EOT

EOT


M thode

Méthode

  • Voir Poly! Pour SLR1.

  • Construction d'états équivalents par inondation des règles possibles.

  • Puis construction de tables dans lesquelles se promène l'automate.

  • Permet des grammaires plus larges (récursivité à gauche).


Construction des ensembles passe 1

Construction des ensembles – passe 1

Si entier:

I0

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I1

Fini!

Si '(':

Si expr :

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I3

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I2

Si primaire:

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

Si axiome, '+', ';', ')' : rien

I2 et I3 ne sont pas " finis ".

I4

Fini!


I0 i1 i4

I0 I1 I4


Construction des ensembles passe 2 i2

Construction des ensembles – passe 2 – I2

Si entier:

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I2

I1

Si '(':

Si expr :

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I5

I2

Si primaire:

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

Si axiome, '+', ')': rien.

On retombe sur I1, I2 et I4.

Nouvel ensemble I5.

Restent donc I3 et I5 à traiter.

I4


I0 i1 i2 i4

I0 I1 I2 I4


Construction des ensembles passe 2 i3

Construction des ensembles – passe 2 – I3

Si '+' :

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I3

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I6

Si ';' :

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I7

Fini !

Si '(', ')', entier, axiome, expr, primaire: rien.

Nouveaux ensembles: I6 qui n'est pas " fini " et I7.

Restent donc I5 et I6 à traiter.


Io i1 i2 i3 i4 i7

IO I1 I2 I3 I4 I7


Construction des ensembles passe 3 i5

Construction des ensembles – passe 3 – I5

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I5

Si '+' :

Si ')' :

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I6

I8

Fini !

Si '(', ';', entier, axiome, expr, primaire: rien.

Nouvel ensemble I8 qui est " fini ".

Reste donc I6 à traiter.


I0 i1 i2 i3 i4 i5 i7 i8

I0 I1 I2 I3 I4 I5 I7 I8


Construction des ensembles passe 3 i6

Construction des ensembles – passe 3 – I6

Si '(':

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I6

I2

Si entier:

Si primaire:

Fini !

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

axiome → expr ';'

expr → expr '+' primaire

expr→primaire

primaire → '(' expr ')'

primaire → entier

I9

I1

Si '+', ')', axiome, expr : rien.

Nouvel ensemble I9.

Plus rien à traiter.


I0 i9

I0 – I9


Table des actions 1

Table des actions (1)

Terminaux

Non-terminaux


Calcul des suivants

Calcul des suivants

A axiome → expr ';'

B expr → expr '+' primaire

C expr→primaire

D primaire → '(' expr ')'

E primaire → entier

Suivant(axiome ):EOT

Suivant(expr): ')' '+' ';'

Suivant(primaire): ')' '+', ';'


Table des actions 2

A axiome → expr ';'

B expr → expr '+' primaire

C expr→primaire

D primaire → '(' expr ')'

E primaire → entier

Table des actions (2)

Réduction: on est à la fin d'une règle et le terminal qui se présente est dans Suivant.


Automate d calages goto

Automate (décalages & goto)

On est à l'état X

File des symboles d'entrée

Pile de travail

  • dY (décalage Y) et gY (goto Y):

    • Poussent le symbole d'entrée

    • Poussent le numéro de l'état courant

    • Vont à l'état Y

    • Distinction: d si symbole Vt, g si Vn

étatX

1

+

2

;

$

Décalage et goto représentent l' " avance " dans une règle avec la consommation d'un Vn ou Vt.

Quand c'est un Vt: lecture du flux d'entrée.

État

X

Y


Automate r ductions

Automate (réductions)

étata

pri

Réd.X (réduction par la règle X)

Ici expr → expr '+' primaire

étatb

+

File des symboles d'entrée

On enlève la définition de la pile de travail

On pousse sa réduction dans la file des symboles

On va à l'état indiqué en haut de la pile de travail

étatg

exp

étatd

(

exp

étate

)

La réduction représente la reconnaissance d'un motif de droite dans une règle, et son remplacement par le nom de la règle.

Ici: expr + primaire est reconnu, et remis pour analyse dans la file d'entrée sous le nom de expr en revenant dans l'état où l'on était avant d'analyser expr + primaire.

+

;

étatx

pri

$

État

W

d


Usage

Usage

A axiome → expr ';'

B expr → expr '+' primaire

C expr→ primaire

D primaire → '(' expr ')'

E primaire → entier

entier+(entier+entier);


Conflits

Conflits

  • shift/reduce

    • Règle:: terminal Règle terminal

    • Règle:: terminal

    • Si deux " terminal " se présentent en séquence, on peut après le premier soit avancer dans la première règle, soit réduire la deuxième.

  • Exemple de C: if (cond1) if (cond2) instr1; else instr2;

    • if_instr:: if ( cond ) instr ;

    • if_instr:: if ( cond ) instr; elseinstr;

    • instr:: if_instr (entre autres)

    • La branche else de l'exemple fera partie du premier ou du second if selon que l’on choisit décalage ou réduction.

  • reduce/reduce

  • Ex. simple: règles identiques (ou acceptent la même séquence)

  • Axiome:: Règle1 | Règle 2

  • Règle1 :: a b c

  • Règle2 :: a b c

  • Pas de shift/shift

  • yacc choisit le shift en cas de conflit shift/reduce.

  • yacc choisit la première règle en cas de conflit reduce/reduce


Lex yacc clones flex byacc bison

produit par yacc.h

(définition des tokens)

bla.l

#include " ….. "

produit par lex.c

analyseur

(b)yacc/

bison

bla.y

produit par yacc.c

(f)lex

gcc

Les noms des fichiers produits dépendent de la combinaison d'outils utilisés(lex/flex – yacc/byacc/bison) et du système d'exploitation

lex / yacc(clones: flex / byacc bison)


Structure des fichiers

%{

Zone où l'on écrit du C. Les inclusions, les objets globaux, les déclarations et les fonctions dont on a besoin plus bas.

%}

Recopie pure et simple du code C

Automate (en C) généré qui exécute, au bon moment, les actions mises entre accolades. Ce code est illisible quoique en C

Zone où l'on décrit les définitions qui seront utiles aux règles, en lex ou yacc

%%

Zone où l'on écrit les règles sous la forme spécifique à chaque outil. On peut y glisser {du C entre accolades}, dans les règles.

%%

{ le C recopié }

Recopie pure et simple du code C

Zone où l'on écrit du C

Structure des fichiers


Exemple de fichier lex

Exemple de fichier lex

%{

#include <stdlib.h>

#include "y.tab.h"

intnum_ligne = 1;

%}

%%

"+" {return '+' ;}

"-" {return '-' ;}

"*" {return '*' ;}

"/" {return '/' ;}

"(" {return '(' ;}

")" {return ')' ;}

";" {return ';' ;}

[0-9]+{return ENTIER;}

[ \t] {/* on ignore blancs et tabs*/}

[\n] { num_ligne ++;}

. {}

%%

Fichier y.tab.h

#define ENTIER 257

TRES IMPORTANT: le format est rigide: pas de blanc avant les définitions, un blanc entre la définition et l'accolade. Sinon l'accolade serait prise dans la définition!

Attention: return 'c', c'est du C qui rend le code ASCII du caractère. Pure convention, on pourrait mettre n'importe quel code.

Le seul effet du code produit est de rendre le numéro du jeton reconnu (donné dans le return) par une fonction intyylex(),et d'exécuter le C entre accolades au bon moment.


Exemple de fichier yacc

Exemple de fichier yacc

%{

ici du C

%}

%token ENTIER

%startdebut

%%

debut: expr ';' ;

expr : expr '+' terme | expr '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')' ;

%%

int main ()

{

if (yyparse()==0) printf("ok\n") ; elseprintf( "ko\n") ;

}

intyyerror(char * s)

{printf( "erreur %s\n",s);  }

intyywrap() {}

Le seul effet est de créer une fonction intyyparse() qui rend 0 si l'analyse s'est bien passée -1 sinon, et exécute le code C entre accolades au bon moment. Elle appelle yylex() au besoin.

L'option –d crée le fichier y.tab.h utile à lex à partir de la liste de %TOKEN. Penser à toujours la mettre.

yacc (byacc, bison) avec le switch –v (verbose) crée un fichier texte d'extension .output qui liste en clair tous les états et les décisions de shift(décalage)/goto/reduction.

yyerror est appelée par yacc chaque fois qu'il y a un souci. On peut l'appeler directement. Elle peut emballer l'erreur avec des infos utiles (ligne, fichier...)

yywrap est à mettre vide. Sert par exemple pour gérer les #include de C.


Les actions

Les actions

debut: expr ';' ;

expr : expr '+' terme | expr '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')' ;

x=Sommet;Tirer;

y=Sommet;Tirer;

Pousser(y § x)

x=Sommet;Tirer;

printf("%d\n", x);

pousser(value);


S quence

Séquence

2+3; 5-2; .

debut: expr ';' ;

expr : expr '+' terme | expr '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')'  ;

Ici place pour fclose et autres ménages.

programme: sequence '.' ;

sequence : sequence instruction | ;

instruction : expr ';';

expr : expr '+' terme | expr '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')'  ;


Ajouter une entr e

Ajouter une entrée

2+?;.

'?'

nouveau token (lex)

nouveau primaire (yacc)

primaire : ENTIER | '(' expr ')' 

| '?' ;

"?" {return '?' ;}

Action:

scanf("%d",&x); Pousser(x);


Variables

Variables

K = 2+3;

K*4;

.

programme: sequence '.' ;

sequence : sequence instruction | ;

instruction : expr ';';

expr : expr '+' terme | expr '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')'  ;

Int Tableau[256] ;

saved_value=value;

Tableau[saved_value] = Sommet ;

programme: sequence '.' ;

sequence : sequence instruction | ;

instruction : expr ';'| NOM_VAR '=' expr ';‘ ;

expr : expr '+' terme | expr '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')'  | '?‘| NOM_VAR ;

Pousser(Tableau[value] );


Vers un compilateur

enum {pousser, plus, moins, mul, divi, afficher, fin};

Vers un compilateur

while (1) {

lire(&code);

switch(code){

case pousser: lire(&val); pousser(val);break;

case plus: x=sommet;tirer…etc…

}

}

2+3;.

variables

Analyseur (Lex & Yacc)

Pousser

2

Pousser

3

Plus

Afficher

Fin

0

2

0

3

1

5

6

pile

Exécuteur

Pousser(2) -- primaire

Pousser(3) -- primaire

y=Sommet;Tirer; -- plus

x=Sommet;Tirer;

Pousser(x+y);

x=Sommet;Tirer; -- instruction

printf("%d\n",x);

ecrire(pousser); ecrire(2) ;-- primaire

ecrire(pousser); ecrire(3) -- primaire

ecrire (plus); -- plus

ecrire(afficher); -- instruction

ecrire(fin)


Ajouter des comparateurs

Ajouter des comparateurs

2>3;.

expr : expr '+' terme | expr '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')'  | '?‘| NOM_VAR ;

Actions

expr : elmt EQ elmt | elmt NE elmt | elmt GT elmt

| elmt GE elmt | elmt LT elmt | elmt LE elmt | elmt ;

elmt : elmt‘ +' terme | elmt '-' terme | terme ;

terme  : terme '*' primaire | terme '/' primaire | primaire ;

primaire : ENTIER | '(' expr ')'  | '?‘| NOM_VAR ;

Noter: pas de récursion à gauche pour éviter l’envie d’écrire A > B > C


Lire le fichier en m moire

Lire le fichier en mémoire

Remplacer

fprintf dans l’analyseur par fwrite

fscanf dans l’exécuteur par fread

Attention : fread et fwrite demandent des pointeurs

Vérifier que ça marche encore

  • Lecture en mémoire (Voir poly)

    • Ouvrir le fichier

    • Aller à la fin (fseek)

    • Lire l’index (ftell) ce qui donne la taille en octets

    • Revenir au début (fseek)

    • Allouer la mémoire

    • -lire tout d’un coup avec une instruction fread

    • fermer le fichier

    • l’oublier.

Remplacer dans l’exécuteur les lectures fichier par l’indexage du tableau lu en mémoire.


Vocabulaire terminal vt

if

if expression then sequence endif ;

if expression then sequence else sequence endif ;

instruction: ……………….. | if_instr ;

if_instr: TOK_IF expression TOK_THEN sequence  TOK_ENDIF ‘;’

| TOK_IF expression TOK_THEN sequence TOK_ELSE sequence TOK_ENDIF ‘;’;

Souci: l’analyseur ne peut pas décider quelle branche choisir avant de « découvrir » le elseou son absence.

Or des actions -potentiellement différentes dans chaque branche- peuvent être faites avant cette détermination, qu’on ne peut pas « défaire ».

On fera une règle qui factorise le début et oblige à l’unicité des actions.

if_instr: debut_if_instr   TOK_ENDIF

| debut_if_instr  TOK_ELSE sequence TOK_ENDIF ;

debut_if_instr : TOK_IF expression TOK_THEN sequence ;


Vocabulaire terminal vt

loop

loop ………………..exit;……..endloop;

Le exit peut être multiple et lui-même dans un test. C’est une instruction (qui doit être dans une boucle mais la syntaxe ne le vérifie pas: à faire).

On peut ainsi programmer toutes les boucles utiles.

instruction: ……………….. | loop_instr | exit_instr ;

loop_instr: TOK_LOOP sequence TOK_ENDLOOP ‘;’ ;

exit _instr: TOK_EXIT ‘;’ ;


La machine virtuelle

La machine virtuelle

  • Un tableau

  • Un index IndexPile permettant d’implémenter des primitives de pile: pousser, tirer, sommet.

  • Un index BasePile mémorisant la place de la première variable du sous-programme courant.

Deux tableaux de service (index des variables locales, adresses des sous-programmes)

Une zone programme adressable, contenant des codes opérations et leurs opérandes.

Un compteur de programme (IndexProgramme)

Un tableau de mémoires globales adressées par leur index, contenant des entiers.

tmp1 & tmp2


  • Login