Vue g n rale
Download
1 / 40

Vue générale - PowerPoint PPT Presentation


  • 83 Views
  • Uploaded on

Vue générale. Pr ZEGOUR DJAMEL EDDINE Ecole Supérieure d’Informatique (ESI) www.zegour.uuuq.com email: [email protected] Vue générale Motivation Structure d‘un compilateur Grammaires Arbres Syntaxiques et Ambiguïté Classification de Chomsky Présentation Z#.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about ' Vue générale' - megan-kirk


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
Vue g n rale

Vue générale

Pr ZEGOUR DJAMEL EDDINE

Ecole Supérieure d’Informatique (ESI)

www.zegour.uuuq.com

email: [email protected]


Vue générale

Motivation

Structure d‘un compilateur

Grammaires

Arbres Syntaxiques et Ambiguïté

Classification de Chomsky

Présentation Z#


Histoire construction des compilateurs
Histoire (Construction des compilateurs)

Autrefois " un mystère ", aujourd'hui l‘une des branches les plus maîtrisées

En informatique.

1957FortranPremiers compilateurs

(Expressions, instructions, procédures)

  • AlgolPremière définition formelle d‘un langage

  • (grammaires sous forme de Backus-Naur, bloc, récursivité, ...)

1970Pascaltypes, machines virtuelles (P-code)

1985C++Orientation objets, exceptions

1995JavaPortabilité

Le cours concerne uniquement les langages impératifs (procéduraux)

langages fonctionnels (Lisp) et langages logiques ( Prolog) exigent d‘autres techniques.


Comment est crit le premier compilateur
Comment est écrit le premier compilateur?

Programmation degré 0 : en binaire (suite de 0 et de 1)

Programmation degré 1 : langage d‘assemblage (LW, JUMP,.)

Programmation degré 2 : langage de programmation (CALL, SINUS,.)

Le premier assembleur est écrit en binaire

Le premier compilateur est écrit en langage d‘assemblage

Aujourd'hui un compilateur pour le langage U est écrit avec un langage V

doté d‘un compilateur écrit dans un langage W.


Pourquoi apprendre la compilation
Pourquoi apprendre la compilation?

Constitue une base pour un ingénieur en informatique

  • Comment les compilateurs fonctionnent?

  • Comment les ordinateurs fonctionnent?(instructions, registres, addressage, déroulement d‘une instruction, ...)

  • Code machine généré

  • (efficacité)

  • C‘est quoi une bonne conception de langage ?

  • Utile dans d‘autres domaines

  • Lecture des requêtes de bases de données ()

  • Lecture des données structurées du type XML, fichier image, ...)

  • Interprétation des lignes de commande

  • ...


Vue générale

Motivation

Structure d‘un compilateur

Grammaires

Arbres Syntaxiques et Ambiguïté

Classification de Chomsky

Présentation Z#


Structure d un compilateur

Analyse lexicale

Unités lexicales

Code de l‘unité

1

(ident)

"val"

3

(assign)

-

2

(number)

10

4

(times)

-

1

(ident)

"val"

5

(plus)

-

1

(ident)

"i"

Valeur de l‘unité

Analyse syntaxique

Statement

Arbre syntaxique

Expression

Term

ident = number * ident + ident

Structure d‘un compilateur

Programme source

v

a

l

=

1

0

*

v

a

l

+

i


Structure d un compilateur1

Optimisation

Génération de code

00101110000

01101101101

00011111010

...

Code machine

Structure d‘un compilateur

Statement

Arbre syntaxique

Expression

Term

ident = number * ident + ident

Analyse sémantique

Représentation

intermédiaire

Arbre syntaxique, table des symboles, ...


Compilateurs une passe
Compilateurs à une passe

Fonctionnement simultané des phases

Scanne une unité

Analyse une unité

Vérifie une unité

Génère le code pour une unité

n

eof?

y

Le programme objet est généré en même temps que le programme source est lu.


Compilateurs plusieurs passes
Compilateurs à plusieurs passes

Les phases sont des programmes séparés qui s‘exécutent séquentiellement

Sémantique

Lexique

Syntaxe

...

Source

Unités lexicales

Arbre

Code

Chaque phase lit à partir d‘un fichier et écrit sur un nouveau fichier

Pourquoi plusieurs passes?

  • Mémoire insuffisante (Aujourd'hui, ce n‘est plus un motif)

  • Langage complexe

  • Portabilité importante


En g n ral compilateurs deux passes

Dépendant du language

Dépendant de la machine

Java

C

Pascal

Pentium

PowerPC

SPARC

Toute combinaison possible

En général: Compilateurs à deux passes

Passe 1

Passe 2

Lexique

Syntaxe

Sémantique

Génération

code

Représentation

intermédiaire

  • Inconvénients

  • Lenteur

  • Plus de mémoire

  • Avantages

  • Meilleure portabilité

  • Combiner les techniques entre les deux passes

  • Optimisations plus simples sur la représentation

  • intermédiaire que sur le code source


Diff rence entre compilateur et interpr teur

Interpréteur

exécute le code source "directement"

  • Les instructions d‘une boucle sontscannées et analysées à chaque

  • itération

scanner

parser

code source

interprétation

Variante: interprétation du code intermédiaire

  • Le code source est traduit dans le code d‘une machinevirtuelle (VM)

  • VM interprète le codesimulant la machine physique

... compilateur ...

VM

code source

Code intermédiaire

(Langage pivot))

Différence entre Compilateur et Interpréteur

Compilateur

Traduit vers le code machine

scanner

parser

...

code generator

loader

code source

code machine


Fonctionnement d un compilateur

Flots de données

Fonctionnement d‘un compilateur

"Programme principal"

Dirige toute la compilation

Analyse Syntaxique

Sémantique

scanner

Génération de code

Fournit les unités lexicales à partir

du code source

génère le code machine

Table des symboles

Maintient des informations sur

les variables et types déclarés

Utilise


Vue générale

Motivation

Structure d‘un compilateur

Grammaires

Arbres Syntaxiques et Ambiguïté

Classification de Chomsky

Présentation Z#


C est quoi une grammaire

Quatre composantes

Symboles terminaux

Sont atomiques

"if", ">=", ident, number, ...

Symboles non

terminaux

Sont dérivés

en unités

Statement, Expr, Type, ...

productions

Règles donnant la décom-

position des non terminaux

Statement = Designator "=" Expr ";".

Designator = ident ["." ident].

...

Symbole de départ

Non terminal axiome

CSharp

C‘est quoi une grammaire?

Exemple

Statement = "if" "(" Condition ")" Statement ["else" Statement].


Notation ebnf

|

(...)

[...]

{...}

Choix

Choix de groupes

Partie optionnelle

Partie répétitive

a | b | c a or b or c

a ( b | c ) ab | ac

[ a ] b ab | b

{ a } b b | ab | aab | aaab | ...

Notation EBNF

Extended Backus-Naur form

John Backus: a développé le premier compilateur Fortran

Peter Naur: définition de Algol60

Symboles

Sens

exemples

Chaîne

Nom

=

.

Dénote une chaîne de caractères

Dénote un symbole T ou NT

Sépare les membres d‘une production

Termine une production

"=", "while"

ident, Statement

A = b c d .

  • Conventions

  • Symboles terminaux : commencent par des lettres minuscules (ex. ident)

  • Symboles non terminaux : commencent par des lettres majuscules (ex. Statement)


Exemple grammaire pour les expressions arithm tiques

Symboles Terminaux

"+", "-", "*", "/", "(", ")"

( 1 instance)

ident, number

(plusieurs instances)

Symboles non terminaux

Expr, Term, Factor

Symbole de départ

Expr

Exemple: Grammaire pour les expressions arithmétiques

Productions

Expr = [ "+" | "-" ] Term { ( "+" | "-" ) Term }.

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

Factor = ident | number | "(" Expr ")".

Expr

Term

Factor


Priorit des op rateurs

=

- ident * number + ident / number - ident

=

- Factor * Factor + Factor / Factor - Factor

=

"*" et "/" ont des priorités supérieures à "+" et "-"

-

Term

+

Term

-

Term

"-" ne porte pas sur a, mais sur a*3

=

Expr

Priorité des opérateurs

Des grammaires peuvent être utilisées pour définir la priorité des opérateurs

Expr = [ "+" | "-" ] Term { ( "+" | "-" ) Term }.

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

Factor = ident | number | "(" Expr ")".

Entrée:- a * 3 + b / 4 - c

Comment transformer la grammaire pour que "-" porte sur a?

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

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

Factor = [ "+" | "-" ] ( ident | number | "(" Expr ")" ).


Premiers d un non terminal
Premiers d‘un non terminal

Avec quels symboles terminaux un non terminal peut commencer?

Expr = ["+" | "-"] Term {("+" | "-") Term}.

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

Factor = ident | number | "(" Expr ")".

First(Factor) =

ident, number, "("

First(Term) =

First(Factor)

= ident, number, "("

First(Expr) =

"+", "-", First(Term)

= "+", "-", ident, number, "("


Suivants d un non terminal
Suivants d‘un non terminal

Quels symboles terminaux peuvent suivre un non terminal ?

Expr = [ "+" | "-" ] Term { ( "+" | "-" ) Term }.

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

Factor = ident | number | "(" Expr ")".

Voir où Expr apparaît dans le coté droit

d‘une production?

Quels sont les symboles terminaux qui

le suivent?

Follow(Expr) =

")", eof

Follow(Term) =

"+", "-", Follow(Expr)

= "+", "-", ")", eof

Follow(Factor) =

"*", "/", Follow(Term)

= "*", "/", "+", "-", ")", eof


Terminologie

Chaîne

Une séquence finie de symboles d‘un alphabet.

Chaîne vide

Dénotée par e

Terminologie

Alphabet

L‘ensemble des symboles terminaux et non terminaux d‘une grammaire

Dénotées par les lettres grecques (a, b, g, ...)

Ex.: a = ident + number

b = - Term + Factor * number


D rivations et r ductions

a=>*b (dérivation indirecte)

a=>g1=>g2=> ...=>gn=>b

a=>Lb (dérivation canonique gauche )

Le non terminal le plus à gauche dans a est dérivé

en premier

a=>Rb (dérivation canonique droite)

Le non terminal le plus à droite dans a est dérivé

en premier

Réduction

C‘est l‘inverse d‘une dérivation.

Si le coté droit d‘une production figure dans b il est remplacé par le non terminal correspondant

Dérivations et Réductions

Dérivation

a

b

a=>b (dérivation directe)

=>

Term + Factor * Factor

Term + ident * Factor

Partie droite d‘une

production de NT

Non terminal NT


D rivation de la cha ne vide annulabilit
Dérivation de la chaîne vide( Annulabilité )

Une chaîne a peut dériver la chaîne vide.

a=>*e

Exemple

A = B C.

B = [ b ].

C = c | d | e.

B peut dériver la chaîne vide : B =>e

C peut dériver la chaîne vide : C =>e

A peut dériver la chaîne vide : A => B C => C =>e


Plus de terminologie
Plus de terminologie

Forme sententielle

Toute chaîne qui peut être dérivée à partir de l‘axiome d‘une grammaire.

Ex1: Expr // Ex2 : Term + Term + Term; Ex3:Term + Factor * ident + Term ...

Phrase du langage

Une forme sententielle uniquement avec des symboles terminaux.

Ex.: ident * number + ident

Phrase pour un non terminal U

xUy forme sentientielle et U=>+u

Si U=>u : phrase simple

Handle

Phrase simple la plus à gauche

Langage (langage formel)

C‘est l‘ensemble de toutes les phrases d‘une grammaire (en général infini).

Ex.: le langage C est l‘ensemble de tous les programmes C corrects syntaxiquement.


R cursion

Récursion directe

A =>w1 A w2

A => A a => A a a => A a a a => b a a a a a ...

Récursion gauche

A = b | A a.

A => a A => a a A => a a a A => ... a a a a a b

Récursion droite

A = b | a A.

A => (A) => ((A)) => (((A))) => (((... (b)...)))

Récursion centrale

A = b | "(" A ")".

Récursion indirecte

A => *w1 A w2

Exemple

Expr => Term => Factor => "(" Expr ")"

Expr = Term { "+" Term }.

Term = Factor { "*" Factor }.

Factor = id | "(" Expr ")".

Récursion

A => *w1 A w2

Une production est récursive si

Utilisée pour représenter des répétitions et des structures emboîtées


Comment liminer la r cursion gauche

La récursion à gauche peut être transformée en une itération

E = T | E "+" T.

Quelles formes sententielles peuvent être dérivées?

T

T + T

T + T + T

...

Ce qui donne la règle itérative EBNF :

E = T { "+" T }.

Comment éliminer la récursion à gauche?

La récursion à gauche constitue un handicap pour

les analyseurs syntaxiques TopDown

Les deux alternatives commencent avec b.

L‘analyseur ne peut décider quoi choisir

A = b | A a.


Vue générale itération

Motivation

Structure d‘un compilateur

Grammaires

Arbres Syntaxiques et Ambiguité

Classification de Chomsky

Présentation Z#


Notation bnf ordinaire

Grammaire BNF pour les expressions arithmétiques itération

  • Alternatives sont transformées en productions séparées

  • Répétition doivent être exprimée par récursion

<Expr> ::= <Sign> <Term>

<Expr> ::= <Expr> <Addop> <Term>

<Sign> ::= +

<Sign> ::= -

<Sign> ::=

<Addop> ::= +

<Addop> ::= -

<Term> ::= <Factor>

<Term> ::= <Term> <Mulop> <Factor>

<Mulop> ::= *

<Mulop> ::= /

<Factor> ::= ident

<Factor> ::= number

<Factor> ::= ( <Expr> )

Notation BNF ordinaire

Symboles terminaux Sont écrits sans quottes (Ex. : ident, +, -)

Symboles non terminaux sont écrits entre < et > (Ex. : <Expr>, <Term>)

Membres d‘une production sont séparés par ::=

  • Avantages

  • Sans méta symboles ( |, (), [], {})

  • Plus facile à construire un arbre syntaxique

  • Inconvénient

  • Lourdeur


Arbre syntaxique

Arbre syntaxique abstrait itération(feuilles = opérandes, nœuds internes = opérateurs)

+

Souvent utilisé comme une représentation interne d‘un programme;

Utilisé pour les optimisations.

*

number

number

ident

Arbre syntaxique

Montre la structure d‘une phrase particulière

Ex. pour 10 + 3 * i

Arbre syntaxique concret(Arbre de l‘analyseur)

Expr

Expr

Addop

Term

Sign

Term

Term

Mulop

Factor

Reflète les priorités des opérateurs :de bas en haut dans l‘arbre.

Factor

Factor

number

+

number

*

ident

e


Ambigu t

2 arbres syntaxiques existent pour cette phrase itération

T

T

T

T

T

T

T

T

T

T

F

F

F

F

F

F

id

*

id

*

id

id

*

id

*

id

Les grammaires ambiguës causent des problèmes dans l‘analyse syntaxique!

Ambiguïté

Une grammaire est ambiguë, si plus d‘un arbre syntaxique peuvent être construits

pour une phrase donnée.

Exemple

phrase:id * id * id

T = F | T "*" T.

F = id.


Viter l ambigu t

Encore mieux : transformation vers EBNF itération

T = F { "*" F }.

F = id.

Éviter l‘ambiguïté

Exemple

T = F | T "*" T.

F = id.

Remarque : seule la grammaire est ambiguë, pas le langage.

La grammaire peut être transformée :

cad. T a la priorité sur F

T

T = F | T "*" F.

F = id.

T

Un seul arbre syntaxique est possible

T

F

F

F

id

*

id

*

id


Ambigu t inh rente

Statement itération

Il n‘existe pas de grammaire

non ambiguë pour ce langage!

Statement

Condition

Condition

Statement

Statement

Solution dans les langages :

le dernier Else se rapporte

au dernier If

Condition

Condition

Statement

Statement

Statement

Statement

Ambiguïté inhérente

Il existe des langages avec des ambiguïtés inévitables.

Exemple: Problème des Else

Statement = Assignment

| "if" Condition Statement

| "if" Condition Statement "else" Statement

| ... .

if (a < b) if (b < c) x = c; else x = b;


Vue générale itération

Motivation

Structure d‘un compilateur

Grammaires

Arbres Syntaxiques et Ambiguïté

Classification de Chomsky

Présentation Z#


Classification des grammaires

class 0 itération

Grammaires non restritives (a et b arbitraires)

Ex.: A = a A b | B c B.

aBc = d.

dB = bb.

class 1

Grammaires à contexte sensitif (a =xUy et b=xuy) ,U=NT

Ex: a A = a b c.

Reconnues par les automates linéaires finis

class 2

Grammaires à contexte-libre (a = NT, b#e)

Ex: A = a b c.

Reconnues par les automates à piles

Seules ces deux classes sont

exploitées dans la construction

des compilateurs.

class 3

Grammairesrégulières (a = NT, b= T | T NT)

Ex: A = b | b B.

Reconnues par les automates finis

Classification des grammaires

Due à Noam Chomsky (1956)

Les grammaires sont des ensembles de productions de la forme a = b.

A => aAb => aBcBb => dBb => bbb

Reconnues par les machines de Turing


Vue générale itération

Motivation

Structure d‘un compilateur

Grammaires

Arbres Syntaxiques et Ambiguïté

Classification de Chomsky

Présentation Z#


Un prototype de langage objet simple z
Un prototype de langage objet simple : z # itération

Un programme est composé d‘une seule classe avec des variables globales et méthodes.

Il n’y a pas de classes externes mais seulement des classes internes.

Les classes internes sont utilisées comme des types de données.

La méthode principale est toujours appelée Main().

Quand le programme est appelé, cette méthode est exécutée en premier


Un prototype de langage objet simple z1
Un prototype de langage objet simple : z # itération

  • Éléments :

  • - constantes de type int (Ex: 123) et char (Ex. 'a') .Pas de constantes chaîne de caractères.

  • variables: toutes les variables structurées contiennent des références (pointeurs);

  • les variables dans la classe principale sont statiques (globales).

  • Types de base : int, char (Unicode, 2 octets)

  • Types structurés: tableau à une dimension et classes internes avec des champs mais sans méthodes.

  • les méthodes sont définies dans la classe principale.

  • procédures prédéfinies : ord, chr, len.  


Exemple de programme z
Exemple de programme z # itération

class P

const int size = 10;

class Table { int pos[]; int neg[]; }

Table val;

{

void Main ()

int x, i;

{

//---------- Initialize val ----------

val = new Table;val.pos = new int[size]; val.neg = new int[size];

i = 0;

while (i < size) { val.pos[i] = 0; val.neg[i] = 0; i++; }

//---------- Read values ----------

read(x);

while (-size < x && x < size) {

if (0 <= x) val.pos[x]++; else val.neg[-x]++;

read(x);

}

}

}


Syntaxe compl te de z
Syntaxe complète de z # itération

Program = "class" ident { ConstDecl | VarDecl | ClassDecl } "{" { MethodDecl } "}".

ConstDecl = "const" Type ident "=" ( number | charConst ) ";".

VarDecl = Type ident { "," ident } ";".

ClassDecl = "class" ident "{" { VarDecl } "}".

MethodDecl = ( Type | "void" ) ident "(" [ FormPars ] ")" { VarDecl } Block.

FormPars = Type ident { "," Type ident }.

Type = ident [ "[" "]" ].

Statement = Designator ( "=" Expr | "(" [ ActPars ] ")" | "++" | "--" ) ";"

| "if" "(" Condition ")" Statement [ "else" Statement ]

| "while" "(" Condition ")" Statement

| "break" ";"

| "return" [ Expr ] ";"

| "read" "(" Designator ")" ";"

| "write" "(" Expr [ "," number ] ")" ";"

| Block

| ";".

Block = "{" { Statement } "}".

ActPars = Expr { "," Expr }.


Syntaxe compl te de z suite
Syntaxe complète de z# (suite) itération

Condition = CondTerm { "||" CondTerm }.

CondTerm = CondFact { "&&" CondFact }.

CondFact = Expr Relop Expr.

Expr = [ "-" ] Term { Addop Term }.

Term = Factor { Mulop Factor }.

Factor = Designator [ "(" [ ActPars ] ")" ]

| number

| charConst

| "new" ident [ "[" Expr "]" ]

| "(" Expr ")".

Designator = ident { "." ident | "[" Expr "]" }.

Relop = "==" | "!=" | ">" | ">=" | "<" | "<=".

Addop = "+" | "-".

Mulop = "*" | "/" | "%".


ad