Vocabulaire Terminal Vt

1. 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.

2. 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.

3. 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

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

5. 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.

6. 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.

7. 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

8. 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

9. 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)

10. 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

11. 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.

12. 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 → ε

13. 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 ?

14. 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

15. 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.

16. 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 → ε

17. 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

18. 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

19. 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

20. 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}.

21. 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}.

22. 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

23. 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

24. 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.

25. 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.

26. 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 ;

27. 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.

28. 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'

29. 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

30. É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

31. É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"); }

32. 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→

33. 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)

34. 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…

35. 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 ';'

36. 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)

37. 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.

38. 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

39. 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 + +

40. 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

41. 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).

42. 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!

43. I0 I1 I4

44. 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

45. I0 I1 I2 I4

46. 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.

47. IO I1 I2 I3 I4 I7

48. 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.

49. I0 I1 I2 I3 I4 I5 I7 I8

50. 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.