traitement sémantique et grammaire dattributs pr zegour djamel eddine ecole supérieure...

Traitement sémantique et grammaire d’attributs

Pr ZEGOUR DJAMEL EDDINE

Ecole Supérieure d’Informatique (ESI)

www.zegour.uuuq.com

email: d_zegour@esi.dz

Traitement Sémantique et grammaire d‘attributs

Traitement sémantique

Grammaires d’attributs (ATG)

Transformations des ATG en un analyseur

Exemples d’applications

Traitement sémantique

L‘analyseur syntaxique vérifie uniquement la syntaxe d‘un programme

Taches du traitement sémantique

• Gestion de la table des symboles- Maintient les informations sur les noms déclarés- Maintient les informations sur les types- Maintient la portée des noms

• Vérifie les conditions de contexte- Gère la portée des noms- Vérifie les types

• Invocation des routines de génération de code

Les actions sémantiques sont intégrées dans l’analyseur syntaxiqueet sont décrites avec les grammaires d’attribut

Actions sémantiques

Plus loin : Analyse de l’entrée

Expr = Term { "+" Term }. L’analyseur syntaxique vérifie si l’entrée est syntaxiquement correcte.

Maintenant : Traduction de l’entrée (Traitement sémantique )

Expr = Term (. int n = 1; .){ "+" Term (. n++; .)} (. Console.WriteLine(n); .).

Ex.: Compter les termes dans une expression

Actions sémantiques

Instructions Java entre (. et .)

Sont exécuté par l’analyseur aux positions où elles apparaissent dans la grammaire

"traduction" :1+2+3 347+1 2909 1

Traitement Sémantique et grammaire d‘attribut

Traitement sémantique

Grammaires d’attributs (ATG)

Transformations des ATG en un analyseur

Exemples d’applications

Attributs

Les symboles non terminaux peuvent retourner des valeurs ( paramètres de sortie)

Term <int val> Term retourne sa valeur numérique comme un attribut de sortie

Les attributs sont utiles dans le processus de traduction

Ex.: Calculer la valeur d’une expression

Expr (. int sum, val; .)= Term<sum>

{ "+" Term<val> (. sum += val; .)} (. Console.WriteLine(sum); .).

"traduction" 1+2+3 647+1 48909 909

Attributs d’entrée

Les symboles non terminaux peuvent aussi avoir des attributs d’entrée(paramètres d’entrée ))

Expr<bool printHex> Afficher le résultat de l’addition hexadécimalesi l’attribut d’entrée printHex est vrai sinon le décimal

Exemple

Expr<bool printHex> (. int sum, val; .)= Term<sum>

{ "+" Term<val> (. sum += val; .)}. (. if (printHex) Console.WriteLine("{0:X}", sum)

else Console.WriteLine("{0:D}", sum); .)

Grammaires d’attributs (ATG)

Notation pour décrire le traitement de traduction

Trois parties :

1.Productions en EBNF

Expr = Term { "+" Term }.

2.Attributs (paramètres des symboles non terminaux)

Term<int val>Expr<bool printHex>

Attributs d’entrée : passer le résultat de la traductionAttributs de sortie : fournit un contexte à partir de l’appelant

3.Actions sémantiques

(. ... Instructions C# Java ou autre... .)

ExempleATG pour les traitement des déclarations

VarDecl= Type

IdentList";" .

IdentLIst= ident

{ "," ident} .

(. Struct type; .)

(. Tab.insert(token.str, type); .)(. Tab.insert(token.str, type); .)

<type><type>

<Struct type>

Ceci est traduit vers les procédures d’analyse suivantes :

static void VarDecl () {Struct type;Type(out type);IdentList(type);Check(Token.SEMICOLON);

}

static void IdentList (Struct type) {Check(Token.IDENT);Tab.Insert(token.str, type);while (la == Token.COMMA) {

Scan();Check(Token.IDENT);Tab.Insert(token.str, type);

}}

Les ATG sont plus concises et plus Lisibles que les procédures d’analyse

Exemple: Traitement des expressions de constantes

Entrée : 3 * (2 + 4)Résultat désiré : 18

Expr= Term

{ "+" Term| "-" Term}.

Term= Factor

{ "*" Factor| "/" Factor}

Factor= number| "(" Expr ")"

(. int val1; .)

(. val += val1; .)(. val -= val1; .)

(. int val1; .)

(. val *= val1; .)(. val /= val1; .)

(. int val1; .)(. val = token.val; .) 3 2 4

2 4

6

6

18

18

3

Factor

* ( 2

Factor

+ 4

Factor

)

Term Term

Expr

Factor

Term

Expr<int val>

<val1><val1>

<int val>

<val1><val1>

<int val>

<val>

<val>

<val>

Traitement Sémantique et grammaire d‘attribut

Traitement sémantique

Grammaires d’attributs (ATG)

Transformations des ATG en un analyseur

Exemples d’applications

Transformation d’une ATG en procédures

Expr<int val> (. int val1; .)= Term<val>

{ "+" Term<val1> (. val += val1; .)| "-" Term<val1> (. val -= val1; .)}.

Production

static void Expr (int val) {int val1;Term(val);for (;;) {

if (la == Token.PLUS) {Scan();Term(val1);val += val1;

} else if (la == Token.MINUS) {Scan();Term(val1);val -= val1;

} else break;}

}

Procédures d‘analyse

Actions sémantique: code Java

Les terminaux n’ont pas d’attributs d’entrée.Pour l’ATG considérée, les terminaux n’ont pas non plus d’attribut de sortie, mais leurs valeurs sont déterminées par token.str or token.val.

Traitement Sémantique et grammaire d‘attribut

Traitement sémantique

Grammaires d’attributs (ATG)

Transformations des ATG en un analyseur

Exemples d’applications

Exemple: Statistiques des ventes

Les ATGs peuvent aussi être utilisées dans d’autres domaines

Exemple: étant donné un fichier avec des nombres des ventes

File = { Article }.Article = Code { Amount } "END"Code = number.Amount = number.

Si l'entrée est syntaxiquement structuré alors les ATGs sont une bonne notation pour décrire son traitement

Exemple d’entrée

3451 2 5 3 7 END3452 4 8 1 END3453 1 1 END...

Sortie désirée

3451 173452 133453 2...

ATG pour les statistiques des ventesFile (. int code, amount; .)= { Article<code, amount> (. Write(code + " " + amount); .)

}.

Article<int code, int amount>= Value<code>

{ (. int x; .)Value<x> (. amount += x; .)

}"END".

Value<int x>= number (. x = token.val; .)

.

static void File () {int code, amount;while (la == number) {

Article(code, number);Write(code + " " + amount);

}}

static void Article ( int code, int amount) {Value( code);while (la == number) {

int x; Value( x); amount += x;}Check(end);

}

static void Value ( int x) { Check(number); x = token.val; }

Code de l’analyseur

Symboles terminaux : number, end, eof

Exemple: Langage de Description des Imagesdécrite par:

POLY(10,40)(50,90)(40,45)(50,0)

END

(10,40)

(50,0)

(40,45)

(50,90)

Syntaxe:

Polygon = "POLY" Point {Point} "END".Point = "(" number "," number ")".

Nous voulons un programme qui lit l’entrée et dessine le polygone

Polygon (. Pt p, q; .)= "POLY"

Point<p> (. Turtle.start(p); .){ "," Point<q> (. Turtle.move(q); .)}"END" (. Turtle.move(p); .).

Point<p> (. Pt p; int x, y; .)= "(" number (. x = t.val; .)

"," number (. y = t.val; .)")" (. p = new Pt(x, y); .).

Nous utilisons "Turtle Graphics" pour le dessin

Turtle.start(p); positionne la tortue (stylo) au point pTurtle.move(q); déplace la tortue vers le point q

tout en dessinant une ligne

Exemple: Transformation des expressions Infixées vers Postfixées

Les expressions arithmétiques en notation infixe peuvent être transformées en notation post fixe3 + 4 * 2 3 4 2 * +(3 + 4) * 2 3 4 + 2 *

Expr =Term{ "+" Term (. Write("+"); .)| "-" Term (. Write("-"); .)}

Term =Factor{ "*" Factor (. Write("*"); .)| "/" Factor (. Write("/"); .)}.

Factor =number (. Write(token.val); .)

| "(" Expr ")".

3

Factor

+ 4

Factor

* 2

Factor

Term

Expr

Term

Write 3 Write 4 Write 2

Write *

Write +