Analyse syntaxique Pr ZEGOUR DJAMEL EDDINE Ecole Suprieure

  • Slides: 51
Download presentation
Analyse syntaxique Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure d’Informatique (ESI) www. zegour. uuuq. com

Analyse syntaxique Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure d’Informatique (ESI) www. zegour. uuuq. com email: d_zegour@esi. dz

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA) Analyse descendante récursive Propriétés LL(1) Traitement

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA) Analyse descendante récursive Propriétés LL(1) Traitement des erreurs

Grammaires à contexte libre Problème Les grammaires régulières ne traitent pas la récursion centrale

Grammaires à contexte libre Problème Les grammaires régulières ne traitent pas la récursion centrale E = x | "(" E ")". On utilise alors les grammaires à contexte libre Définition Une grammaire est dite à contexte libre (CFG) si toutes ses productions ont la forme: A = a. A est un NTS, a séquence non vide de TS et NTS En EBNF le coté droit a peut aussi contenir les meta-symboles |, (), [] and {} Exemple Expr = Term { ( "+" | "-" ) Term }. Term = Factor { ( "*" | "/" ) Factor }. Factor = id | "(" Expr ")". Récursion centrale indirecte Les grammaires à contexte libre peuvent être reconnues par les automates à pile (PDA)

Automates à pile : Push-Down Automaton(PDA) Caractéristiques • Permet les transitions avec des symboles

Automates à pile : Push-Down Automaton(PDA) Caractéristiques • Permet les transitions avec des symboles terminaux et des symboles non terminaux • Utilise une pile pour sauvegarder les états visités Exemple E = x | "(" E ")". x E stop E reconnu revenir 1 arc continuer à partir de là avec E E/1 État lecture État réduire ( ) E x E/3 E/1 ( E. . . ) Appel récursif de l‘automate E

Automates à pile (suite) x E E/1 ( ) E x stop E/3 E/1

Automates à pile (suite) x E E/1 ( ) E x stop E/3 E/1 ( ) E E/3 . . . Peut être simplifié comme suit x E stop ( E/1 x E ( ) Utilise une pile pour trouver le chemin de retour des états visités E/3

Comment fonctionne un PDA? Exemple: ((x)) x 0 E E/1 1 x ( E

Comment fonctionne un PDA? Exemple: ((x)) x 0 E E/1 1 x ( E 2 3 ) 4 E/3 ( stop Les états visités sont rangés dans une pile Pile 0. 0221. 02234. 0234. 0. Reste à analyser ((x)) x)) )) E)) )) ) E 0 ( 2 E x E 1 3 E/1 ) stop E 3 ) 4 E/3

Grammaires régulières et Grammaires à contexte libre Grammaires régulières Utilisées pour Reconnues par Grammaires

Grammaires régulières et Grammaires à contexte libre Grammaires régulières Utilisées pour Reconnues par Grammaires à contexte libre Lexique Syntaxe DFA (sans pile) PDA (avec pile) Entrée DFA (état) pile Productions A = a | b C. A = a.

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA Analyse descendante récursive Propriétés LL(1) Traitement

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA Analyse descendante récursive Propriétés LL(1) Traitement des erreurs

Analyse descendante récursive • Technique d‘analyse Top-down (de haut en bas) • L‘arbre syntaxique

Analyse descendante récursive • Technique d‘analyse Top-down (de haut en bas) • L‘arbre syntaxique est construit du symbole initial(axiome) vers la phrase (top-down) Exemple grammaire Entrée A = a A c | b b. abbc Symbole de départ A A ? Entrée a b b Quelle est L‘alternative qui convient? c a A A c a ? a b b c a La bonne alternative est sélectionnée utilisant. . . • L‘unité lexicale courante de l‘entrée • Les premiers symboles terminaux des alternatives d‘une production A c b b c

Variables statiques de l‘analyseur syntaxique Unité lexicale courante A tout moment l‘analyseur connaît la

Variables statiques de l‘analyseur syntaxique Unité lexicale courante A tout moment l‘analyseur connaît la prochaine unité lexicale static int la; // code de l‘unité lexicale courante Il utilise deux variables pour les unités lexicales (pour la phase sémantique) static Token token; // unité déjà reconnue static Token la. Token; // unité courante non encore reconnue Ces variables sont mises à jour dans la méthode Scan() static void Scan () { Entrée token = la. Token; la. Token = Scanner. Next(); la = la. Token. kind; } token la. Token ident assign ident Déjà reconnues Scan() est appelée au début de l‘analyse. La première unité est dans la plus la ident

Comment analyser les symboles terminaux? Modèle Symbole à analyser: Action de l‘analyseur: a Check(a);

Comment analyser les symboles terminaux? Modèle Symbole à analyser: Action de l‘analyseur: a Check(a); On a besoin des méthodes suivantes static void Check (int expected) { if (la == expected) Scan(); // recognized => read ahead else Error( Token. names[expected] + " expected" ); } public static void Error (string msg) { Console. Write. Line("– line {0}, col {1}: {2}", la. Token. line, la. Token. col, msg); throw new Exception("Panic Mode"); } Dans la class Token: Ordonné par code Les noms des symboles terminaux sont déclarés comme des constantes dans la classe Token public static string[] names = {"? ", "identifier", "number", . . . , "+", "-", . . . }; public const int NONE = 0, IDENT = 1, NUMBER = 2, . . . , PLUS = 4, MINUS = 5, . . . ;

Comment analyser les symboles non terminaux? Modèle Symbole à analyser : Action de l‘analyseur

Comment analyser les symboles non terminaux? Modèle Symbole à analyser : Action de l‘analyseur : A A(); // Appel à la méthode d‘analyse de A Chaque symbole non terminal est reconnu par une méthode avec le même nom private static void A() {. . . parsing actions for the right-hand side of A. . . } Initialisation de l‘analyseur public static void Parse () { Scan(); // initialise token, la. Token et la Program(); // appelle la méthode d’analyse de l’axiome Check(Token. EOF); // à la fin, l’entrée doit être vide }

Comment analyser les séquences? Modèle production: A = a B c. Méthode de l‘analyseur:

Comment analyser les séquences? Modèle production: A = a B c. Méthode de l‘analyseur: static void A () { // la contains a terminal start symbol of A Check(a); B(); Check(c); // la contains a follower of A } Simulation A = a B c. B = b b. static void A () { Check(a); B(); Check(c); } static void B() { Check(b); } Entrée restante abbc c bbc bc c

Comment analyser les alternatives Modèle a|b|g Action de l‘analyseur a, b, g sont des

Comment analyser les alternatives Modèle a|b|g Action de l‘analyseur a, b, g sont des expressions EBNF if (la in First(a)) {. . . parse a. . . } else if (la in First(b)) {. . . parse b. . . } else if (la in First(g)) {. . . parse g. . . } else Error(". . . "); // find a meaninful error message Exemple A = a B | B b. B = c | d. First(a. B) = {a} First(Bb) = First(B) = {c, d} static void A () { if (la == a) { Check(a); B(); } else if (la == c || la == d) { B(); Check(b); } else Error ("invalid start of A"); } static void B () { if (la == c) Check(c); else if (la == d) Check(d); else Error ("invalid start of B"); } exemples: analyser a d et c b analyser b b

Comment analyser les Options EBNF Modèle [a] Action de l‘analyseur Exemple A = [

Comment analyser les Options EBNF Modèle [a] Action de l‘analyseur Exemple A = [ a b ] c. static void A () { if (la == a) { Check(a); Check(b); } Check(c); } Exemple: analyser a b c analyser c a est une expression EBNF if (la in First(a)) {. . . parse a. . . } // no error branch!

Comment analyser les itérations EBNF Modèle {a} Action de l‘analyseur a est une expression

Comment analyser les itérations EBNF Modèle {a} Action de l‘analyseur a est une expression EBNF while (la in First(a)) {. . . parse a. . . } Exemple A = a { B } b. B = c | d. Ou bien. . . static void A () { Check(a); while (la == c || la == d) B(); Check(b); } Exemple: analyser a c d c b analyser a b static void A () { Check(a); while (la != b && la != Token. EOF) B(); check(b); } Sans EOF: danger d‘une boucle infinie, si b n‘existe pas dans l‘entrée

Cas des ensembles ‘First’ grands Si l‘ensemble First a plus de 4 : utiliser

Cas des ensembles ‘First’ grands Si l‘ensemble First a plus de 4 : utiliser la classe Bit. Array Exemple: First(A) = {a, b, c, d, e} First(B) = {f, g, h, i, j} Les ensembles First sont initialisés au début du programme using System. Collections; static Bit. Array first. A = new Bit. Array(Token. names. Length); first. A[a] = true; first. A[b] = true; first. A[c] = true; first. A[d] = true; first. A[e] = true; static Bit. Array first. B = new Bit. Array(Token. names. Length); first. B[f] = true; first. B[g] = true; first. B[h] = true; first. B[i] = true; first. B[j] = true; Exemple C = A | B. static void C () { if (first. A[la]) A(); else if (first. B[la]) B(); else Error("invalid C"); }

Cas des ensembles ‘First’ grands Si l‘ensemble a moins de 4 éléments: utiliser des

Cas des ensembles ‘First’ grands Si l‘ensemble a moins de 4 éléments: utiliser des vérifications explicites (plus rapide) Exemple : First(A) = {a, b, c} if (la == a || la == b || la == c). . . Si l‘ensemble est un intervalle: utiliser un test d‘intervalle if (a <= la && la <= c). . . Les codes unités lexicales sont souvent choisis de telle sorte qu‘ils forment des intervalles Exemple First(A) = { a, c, d } First(B) = { a, d } First(C) = { b, e } const int a = 0, d = 1, c = 2, b = 3, e = 4, First(B) First(A) First(C)

Optimisations Éviter les multiples vérifications A = a | b. static void A ()

Optimisations Éviter les multiples vérifications A = a | b. static void A () { if (la == a) Scan(); // no Check(a); else if (la == b) Scan(); else Error("invalid A"); } A = { a | B d }. B = b | c. static void A () { while (la == a || la == b || la == c) { if (la == a) Scan(); else { // no check any more B(); Check(d); } // no error case } } Schéma plus efficace pour analyser les alternatives dans une itération A = { a | B d }. static void A () { for (; ; ) { if (la == a) Scan(); else if (la == b || la == c) { B(); Check(d); } else break; } }

Optimisations Modèle d’une itération fréquente Exemple a { separator a } ident { ",

Optimisations Modèle d’une itération fréquente Exemple a { separator a } ident { ", " ident } for (; ; ) {. . . parse a. . . if (la == separator) Scan(); else break; } for (; ; ) { Check(ident); if (la == Token. COMMA) Scan(); else break; } Exemple d‘entrée: a , b , c :

Déterminer correctement les ensembles ‘First’ Grammaire A = B a. B = {b}c |

Déterminer correctement les ensembles ‘First’ Grammaire A = B a. B = {b}c | [d] | e. First b et c d et a (!) C= De | f. D = { d }. d et e (D est ‘annulable’!) f e Méthodes d‘analyse static void A () { B(); Check(a); } static void B () { if (la == b || la == c) { while (la == b) Scan(); Check(c); } else if (la == d || la == a) { if (la == d) Scan(); } else if (la == e) { Scan(); } else Error("invalid B"); } static void C () { if (la == d || la == e) { D(); Check(e); } else if (la == f) { Scan(); } else Error("invalid C"); } static void D () { while (la == d) Scan(); }

Descente récursive et arbre syntaxique L‘arbre syntaxique est construit implicitement • Représente les méthodes

Descente récursive et arbre syntaxique L‘arbre syntaxique est construit implicitement • Représente les méthodes actives à un moment donné • Représente les productions utilisées Exemple A = a B c. B = d e. call A() static void A () { Check(a); B(); Check(c); } A a B reconnaît a call B() static void B () { Check(d); Check(e); } A a B d reconnaît d et e Retour de B() c A en exécution c e A a A en exécution B A en exécution c " pile"

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA Analyse descendante récursive Propriétés LL(1) Traitement

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA Analyse descendante récursive Propriétés LL(1) Traitement des erreurs

Propriétés LL(1) Pré condition pour l‘analyse descendante récursive LL(1). . . peut être analysé

Propriétés LL(1) Pré condition pour l‘analyse descendante récursive LL(1). . . peut être analysé de gauche ( Left) à droite avec des dérivations canoniques gauche (Left) ( le NTS le plus à gauche est dérivé en premier ) et utilise une seule unité lexicale (1) de l‘entrée Définition 1. Une grammaire est LL(1) si toutes ses productions sont LL(1). 2. Une production A est LL(1) si pour toutes ses alternatives a 1 | a 2 |. . . | an la condition suivante est vérifiée: First(ai) Intersection First(aj) = {} ( pour tout i et j) [ Au plus un ak peut être vide. Et dans ce cas First(ai) Intersection Follow(A) = {} ( pour tout i #k)] En d‘autres termes • Les symboles terminaux de début de toutes les alternatives d‘une production doivent être disjoints deux à deux. • L‘analyseur doit être capable de choisir l‘une des alternatives par la consultation de la l‘unité lexicale courante.

Comment éliminer les conflits LL(1) ? Factorisation If. Statement = "if" "(" Expr ")"

Comment éliminer les conflits LL(1) ? Factorisation If. Statement = "if" "(" Expr ")" Statement | "if" "(" Expr ")" Statement "else" Statement. Extraire la séquence commune de début If. Statement = "if" "(" Expr ")" Statement ( | "else" Statement ). . Ou en EBNF If. Statement = "if" "(" Expr ")" Statement [ "else" Statement ]. Quelquefois les non terminaux doivent être remplacés avant factorisation Statement = Designator "=" Expr "; " | ident "(" [ Actual. Parameters ] ")" "; ". Designator = ident { ". " ident }. Remplacer Designator dans Statement = ident { ". " ident } "=" Expr "; " | ident "(" [ Actual. Parameters ] ")" "; ". ensuite factoriser Statement = ident ( { ". " ident } "=" Expr "; " | "(" [ Actual. Parameters ] ")" "; " ).

Comment éliminer la Récursion gauche La récursion à gauche est toujours un conflit LL(1)

Comment éliminer la Récursion gauche La récursion à gauche est toujours un conflit LL(1) Par exemple Ident. List = ident | Ident. List ", " ident. génère les phrases suivantes ident ", " ident. . . Peut toujours être remplacée par une itération Ident. List = ident { ", " ident }.

Conflits LL(1) cachés Les itérations et les options EBNF sont des alternatives cachées A

Conflits LL(1) cachés Les itérations et les options EBNF sont des alternatives cachées A = [ a ] b. Idem A = a b | b. a et b sont des expressions EBNF Règles A = [ a ] b. A = { a } b. First(a) Inter First(b) doit être {} A = a [ b ]. A = a { b }. First(b) Inter Follow(A) doit être {} A=a|. First(a) Inter Follow(A) doit être {}

Éliminer les conflits LL(1) cachés Name = [ ident ". " ] ident. Où

Éliminer les conflits LL(1) cachés Name = [ ident ". " ] ident. Où est le conflit et comment l‘éliminer? Name = ident [ ". " ident ]. Cette nouvelle production est elle LL(1) ? Nous devons vérifier si First(". " ident) Intersection Follow(Name) = {} Prog = Declarations "; " Statements. Declarations = D { "; " D }. Où est le conflit et comment l‘éliminer? Remplacer Declarations dans Prog = D { "; " D } "; " Statements. First("; " D) Inter First("; " Statements) # {} Prog = D "; " { D "; " } Statements. Nous devons encore vérifier si First(D "; ") Inter First(Statements) = {}

Problème des ‘Else’ L‘ instruction If en Java Statement = "if" "(" Expr ")"

Problème des ‘Else’ L‘ instruction If en Java Statement = "if" "(" Expr ")" Statement [ "else" Statement ] |. . C‘est un conflit LL(1) ! First("else" Statement) Inter Follow(Statement) = {"else"} C‘est même une ambiguïté qui ne peut être éliminée Statement if (expr 1) if (expr 2) stat 1; else stat 2; Statement On peut construire 2 arbres syntaxiques différents!

Problème des ‘Else’ Solution Statement = "if" "(" Expr ")" Statement [ "else" Statement

Problème des ‘Else’ Solution Statement = "if" "(" Expr ")" Statement [ "else" Statement ] |. . Si la prochaine unité est "else" L‘analyseur prend comme option: le "else" est associé au dernier "if" if (expr 1) if (expr 2) stat 1; else stat 2; Statement

Autres exigences pour une grammaire (Pré conditions pour les analyseurs syntaxiques) Complétude Pour chaque

Autres exigences pour une grammaire (Pré conditions pour les analyseurs syntaxiques) Complétude Pour chaque NTS il doit y avoir une production A=a. BC. B=bb. erreur! pas de production pour C Dérivabilité Chaque NTS doit être dérivable (directement ou indirectement) en une chaîne de TS A=a. B|c. B=b. B. erreur! B ne peut être dérivé en une chaîne de TS Non-circularité Un NTS ne doit pas être dérivable (directement ou pas) en lui-même (A => B 1 => B 2 =>. . . => A) A=ab|B. B=bb|A. erreur! cette grammaire est circulaire car A => B => A

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA Analyse descendante récursive Propriétés LL(1) Traitement

Analyse syntaxique Grammaires contexte-libre et Automates à pile(PDA Analyse descendante récursive Propriétés LL(1) Traitement des erreurs

Objectifs du traitement des erreurs syntaxiques Exigences 1. 2. 3. 4. Déterminer le maximum

Objectifs du traitement des erreurs syntaxiques Exigences 1. 2. 3. 4. Déterminer le maximum d‘erreurs en une seule compilation Pas de bug (quelque soit l‘erreur) Ne pas ralentir l‘exécution en traitant les erreurs Ne pas gonfler le code Techniques pour l‘analyse descendante récursive • Mode panique • Utilisation des symboles de reprise (ancres) • Utilisation des symboles spéciaux de reprise

Mode panique L'analyseur abandonne après la première erreur static void Error (string msg) {

Mode panique L'analyseur abandonne après la première erreur static void Error (string msg) { Console. Write. Line("-- line {0}, col {1}: {2}", la. Token. line, la. Token. col, msg); throw new Exception("Panic Mode - exiting after first error"); } Avantages • économique • suffisant pour les langages de commandes ou pour les interpréteurs Inconvénients • Non appropriée pour la production des compilateurs de qualité

Traitement des erreurs utilisant les ancres Exemple Entrée attendue: Entrée réelle: a b c

Traitement des erreurs utilisant les ancres Exemple Entrée attendue: Entrée réelle: a b c d. . . a x y d. . . Récupération(synchronise l‘entrée restante avec la grammaire) 1. Trouver l’ "unité de reprise " (ancre) avec laquelle l‘analyseur peut continuer après l‘erreur Quelles sont les unités avec lesquelles l‘analyseur peut continuer dans la situation donnée? c successeur de b (qui était attendu à la position de l‘erreur) d successeur de b c. . . Les unités de reprise (ancre) à cette position sont {c, d, . . . } 2. Sauter les unités jusqu‘à ce que unité de reprise soit trouvée. x et y sont sautées dans l‘exemple, mais d est un ancre; l‘analyseur peut continuer avec. 3. Conduire l'analyseur à la position dans la grammaire où il peut continuer. (remonter dans l‘arbre syntaxique)

Détermination des ancres Chaque méthode d‘analyse d‘un non terminal A possède les successeurs courant

Détermination des ancres Chaque méthode d‘analyse d‘un non terminal A possède les successeurs courant de A comme paramètres sux. . . successeurs de tous les NTS, qui sont en exécution static void A (Bit. Array sux) {. . . } Dépendant du contexte courant, sux. A peut dénoter différents ensembles a. . . B eof A b. . . B eof b C d a A f . . . sux. A = {b, eof} e . . . sux. A = {f, d, e, eof} sux contient toujours eof (le successeur du symbole de départ)

Traitement des symboles terminaux Grammaire A =. . . a s 1 s 2.

Traitement des symboles terminaux Grammaire A =. . . a s 1 s 2. . . sn. si : TS ou NTS Action de l‘analyseur check(a, sux. A Union First(s 1) Union First(s 2). . . Union First(sn)); Peut être déterminé au moment de la compilation Doit être déterminé au moment de l‘exécution static void Check (int expected, Bit. Array sux) {. . . } Exemple A = a b c. static void A (Bit. Array sux) { Check(a, Add(sux, fs 1)); Check(b, Add(sux, fs 2)); Check(c, sux); } static Bit. Array fs 1 = new Bit. Array(); fs 1[b] = true; fs 1[c] = true; Rempli au début du programme static Bit. Array Add (Bit. Array a, Bit. Array b) { Bit. Array c = (Bit. Array) a. Clone(); c. Or(b); return c; }

Traitement des symboles non terminaux Grammaire A =. . . B s 1 s

Traitement des symboles non terminaux Grammaire A =. . . B s 1 s 2. . . sn. Action de l‘analyseur B(sux. A Union First(s 1) Union First(s 2). . . Union First(sn)); Exemple A = a B c. B = b b. static void A (Bit. Array sux) { Check(a, Add(sux, fs 3)); B(Add(sux, fs 4)); Check(c, sux); } static void B (Bit. Array sux) { Check(b, Add(sux, fs 5)); Check(b, sux); } fs 3 = {b, c} fs 4 = {c} fs 5 = {b} La méthode d‘analyse pour l‘axiome S est appelée S(fs 0); où fs 0 = {eof}

Sauter les unités invalides Les erreurs sont détectées dans check() static void Check (int

Sauter les unités invalides Les erreurs sont détectées dans check() static void Check (int expected, Bit. Array sux) { if (la == expected) Scan(); else Error(Token. names[expected] + " expected", sux); } Après l‘affichage du message les unités sont sautées jusqu‘à la rencontre d‘une unité de reprise static void Error (string msg, Bit. Array sux) { Console. Write. Line("-- line {0}, col {1}: {2}", la. Token. line, la. Token. col, msg); errors++; while (!sux[la]) Scan(); // while (la # sux) Scan(); } static int errors = 0; // number of syntax errors detected

Synchronisation avec la grammaire Exemple A A = a B e. B = b

Synchronisation avec la grammaire Exemple A A = a B e. B = b c d. static void A (Bit. Array sux) { Check(a, Add(sux, fs 1)); B(Add(sux, fs 2)); Check(e, sux); } static void B (Bit. Array sux) { Check(b, Add(sux, fs 3)); Check(c, Add(sux, fs 4)); Check(d, sux); } a Entrée a eof B b c b x e sux. A = {eof} sux. B = {e, eof} d e eof L‘erreur est détecté ici; ancres = {d, e, eof} 1. 2. 3. 4. 5. 6. x est sauté; la == e ( dans ancres) L‘analyseur continue: Check(d, sux); Détecte de nouveau une erreur; ancres = {e, eof} aucune unité est sautée, car la == e (dans ancres) L‘analyseur retourne de B() et lance Check(e, sux); Recouvrement réussi! Une fois l‘erreur détectée l‘analyseur avance jusqu‘à trouver un endroit dans la grammaire qui concorde avec l‘unité courante.

Supprimer les faux messages d‘erreur Durant le recouvrement de l‘erreur l‘analyseur produit des faux

Supprimer les faux messages d‘erreur Durant le recouvrement de l‘erreur l‘analyseur produit des faux messages d‘erreur Résolu par une simple heuristique Si moins de 3 unités sont reconnues correctement depuis la dernière erreur, l'analyseur suppose que la nouvelle erreur est une fausse erreur. Les fausses erreurs ne sont pas affichées static int err. Dist = 3; // next error should be reported static void Scan () {. . . err. Dist++; // one more token recognized } public static void Error (string msg, Bit. Array sux) { if (err. Dist >= 3) { Console. Write. Line("-- line {0}, col {1}: {2}", la. Token. line, la. Token. col, msg); errors++; } while (!sux[la]) Scan(); err. Dist = 0; // counting is restarted }

Traitement des alternatives A=a|b|g. a, b, g sont des expressions EBNF static void A

Traitement des alternatives A=a|b|g. a, b, g sont des expressions EBNF static void A (Bit. Array sux) { // the error check is already done here so that the parser can synchronize with // the starts of the alternatives in case of an error if (la not in (First(a) Or First(b) Or First(g))) Error("invalid A", sux Or First(a) Or First(b) Or First(g)); // la matches one of the alternatives or is a legal successor of A if (la in First(a)). . . parse a. . . else if (la in First(b)). . . parse b. . . else. . . parse g. . . // no error check here; any errors have already been reported } First(a) Or First(b) Or First(g) peut être déterminé au moment de la compilation sux Or. . . est déterminé au moment de l‘exécution

Traitement des Options et Itérations EBNF Options A = [ a ] b. static

Traitement des Options et Itérations EBNF Options A = [ a ] b. static void A (Bit. Array sux) { // error check already done here, so that the parser can // synchronize with the start of a in case of an error if (la not in (First(a) Or First(b))) Error(". . . ", sux Or First(a) Or First(b)); // la matches a or b or is a successor of A if (la in First(a)). . . parse a. . . ; . . . parse b. . . } Itérations A = { a } b. static void A (Bit. Array sux) { for (; ; ) { // the loop is entered even if la not in First(a) if (la in First(a)). . . parse a. . . ; // correct case 1 else if (la in First(b) Or sux) break; // correct case 2 else Error(". . . ", sux Or First(a) Or First(b)); // error case }. . . parse b. . . }

Exemple A = a B | b {c d}. B = [b] d. static

Exemple A = a B | b {c d}. B = [b] d. static void A (Bit. Array sux) { if (la != a && la != b) Error("invalid A", Add(sux, fs 1)); // fs 1 = {a, b} if (la == a) { Scan(); B(sux); } else if (la == b) { Scan(); for (; ; ) { if (la == c) { Scan(); Check(d, Add(sux, fs 2)); // fs 2 = {c} } else if (sux[la]) { break; } else { Error("c expected", Add(sux, fs 2)); } } static void B (Bit. Array sux) { if (la != b && la != d) Error("invalid B", Add(sux, fs 3)); // fs 3 = {b, d} if (la == b) Scan(); Check(d, sux); }

En résumé Traitement des erreurs avec des symboles de reprises (ancres) Avantage + applicable

En résumé Traitement des erreurs avec des symboles de reprises (ancres) Avantage + applicable automatiquement Inconvénients - Ralentit l‘analyse - gonfle le code de l‘analyseur - complexe

Traitement des erreurs avec des ancres spéciaux Le traitement est seulement fait à des

Traitement des erreurs avec des ancres spéciaux Le traitement est seulement fait à des positions particulières Les mot-clés apparaissent à des positions uniques dans la grammaire Ensemble d‘ancres Exemple • Début d‘instruction: if, while, do, . . . • Début de déclaration: public, static, void, . . . Problème: ident peut figurer à plusieurs endroits! ident n‘est pas un ancre sûr. Il est donc omis de l‘ensemble des ancres Code à insérer aux points de synchronisation L‘ensemble des ancres à ce point de synchronisation. . . if (la not in expected. Symbols) { Error(". . . "); // no successor sets; no skipping of tokens in Error() while (la not in (expected. Symbols Or {eof})) Scan(); } Pour éviter la boucle infinie. . . • Pas besoin de passer les ensembles successeur aux méthodes de l‘analyseur • Les ensembles d‘ancres sont connus avant l‘exécution • Après une erreur l‘analyseur ignore des unités jusqu‘au prochain point de synchronisation

Exemple Synchronisation au début d‘une instruction static void Statement () { if (!first. Stat[la])

Exemple Synchronisation au début d‘une instruction static void Statement () { if (!first. Stat[la]) { Error("invalid start of statement"); while (!first. Stat[la] && la != Token. EOF) Scan(); err. Dist = 0; } if (la == Token. IF) { Scan(); Check(Token. LPAR); Conditions(); Check(Token. RPAR); Statement(); if (la == Token. ELSE) { Scan(); Statement(); } } else if (la == Token. WHILE) {. . . } static Bit. Array first. Stat = new Bit. Array(); first. Stat[Token. WHILE] = true; first. Stat[Token. IF] = true; . . . le reste de l‘analyseur reste inchangé (comme s‘il n‘ y a pas de traitement d‘erreur) Pas de synchronisation dans Error() public static void Error (string msg) { if (err. Dist >= 3) { Console. Write. Line("-- line {0}, col {1}: {2}", la. Token. line, la. Token. col, msg); errors++; } heuristics with err. Dist can also err. Dist = 0; be applied here }

Exemple de recouvrement static void Statement () { if (!first. Stat[la]) { Error("invalid start

Exemple de recouvrement static void Statement () { if (!first. Stat[la]) { Error("invalid start of statement"); while (!first. Stat[la] && la != Token. EOF) Scan(); err. Dist = 0; } if (la == Token. IF) { Scan(); Check(Token. LPAR); Condition(); Check(Token. RPAR); Statement(); if (la == Token. ELSE) { Scan(); Statement(); }. . . } static void Check (int expected) { if (la == expected) Scan(); else Error(. . . ); } public static void Error (string msg) { if (err. Dist >= 3) { Console. Write. Line(. . . ); errors++; } err. Dist = 0; } Entrée erronée: if a > b then max = a; la action if a Scan(); Check(LPAR); Condition(); check(RPAR); Statement(); then max if dans first. Stat , ok message d‘erreur: ‘(‘ attendue reconnaît a > b message d‘erreur: ‘)’ attendue then ne correspond pas, donc erreur, mais pas de message d‘erreur then est sauté; synchronisation avec ident (si dans first. Stat)

Synchronisation au début d‘une itération Exemple Block = "{" { Statement } "}". Modèle

Synchronisation au début d‘une itération Exemple Block = "{" { Statement } "}". Modèle standard dans ce cas static void Block () { Check(Token. LBRACE); while (first. Stat[la]) Statement(); Check(Token. RBRACE); } Problème: si la prochaine unité ne correspond pas à une instruction la boucle n‘est pas exécutée. Le point de synchronisation dans Statement n‘est jamais atteint.

Synchronisation au début d‘une itération Exemple Block = "{" { Statement } "}". C‘est

Synchronisation au début d‘une itération Exemple Block = "{" { Statement } "}". C‘est meilleur de synchroniser au début de l‘itération static void Block() { Check(Token. LBRACE); for (; ; ) { if (la in First(Statement)) Statement(); // correct case 1 else if (la in {rbrace, eof}) break; // correct case 2 else { // error case Error("invalid start of Statement"); do Scan(); while (la (First(Statement) union {rbrace, eof})); err. Dist = 0; } } Check(Token. RBRACE); } Pas de synchronisation dans Statement() static void Statement () { if (la == Token. IF) { Scan(); . . . }

En résumé Traitement des erreurs avec des symboles de reprises spéciaux Avantages + ne

En résumé Traitement des erreurs avec des symboles de reprises spéciaux Avantages + ne ralentit pas l‘exécution de l‘analyseur + ne gonfle pas le code de l‘analyseur + simple Inconvénients - demande plus d‘expérience