SlideShare une entreprise Scribd logo
1  sur  109
Télécharger pour lire hors ligne
Compilation
Présenté par Yann Caron
skyguide
ENSG Géomatique
Plan du cours
Grammaire
Analyse Lexicale
Algorithme LL(0)
Analyse Syntaxique
Algorithmes LL(k), LL(*) et LR
Arbre Syntaxique (AST)
Vue d’ensemble
✔ La Syntaxe est l’étude de la façon dont les
mots sont organisés pour construire des
phrases
✔ La syntaxe ne s’intéresse pas à la
sémantique des mots (les paradigmes)
✔ Par contre l’analyse syntaxique peut
apporter de l’information pour l’analyse
sémantique future
3/109
Vue d’ensemble
✔ Analyseur lexical : Transforme une chaîne
de lettres en une chaîne de mots typés
appelés Lexems (token)
✔ Ex : [ 87 (number), ‘+’ (symbol), 3 (number) ]
✔ Analyseur syntaxique: Transforme une
chaîne de lexems en un arbre syntaxique
(AST)
4/109
Vue d’ensemble
5/109
77
**
33
++
bb
==
aa
setset
s e t a = 7 * 3 + b
Vue d’ensemble
6/109
Analyseur
lexical
Lexer
Analyseur
lexical
Lexer
Analyseur
syntaxique
Parser
Analyseur
syntaxique
Parser
LexemesSource Analyse
(grammaire)
ASTAST
Production
Optimisation
CompilationCompilation
InterprétationInterprétation TraductionTraduction
CodeGen
Analyse
Sémantique
Vue d’ensemble
✔ Généralement :
✔ L’analyseur lexical utilise une grammaire
régulière
✔ Automate fini lit de gauche à droite
✔ L’analyseur syntaxique utilise une
grammaire non-contextuelle (context free)
✔ Encapsulation (exemple bien parenthésé)
7/109
Hiérarchie de Chomsky
✔ voir le cours sur la théorie de langages
✔ langages formels
✔ 4 classes de langages
8/109
Analyseur Lexical
Grammaire régulière
Automate fini
Analyseur Syntaxique
Grammaire non contextuelle
(CFG - Context Free Grammar)
Automate à pile (récursion)
Vue d’ensemble
✔ Choix à plusieurs niveaux
9/109
Vue d’ensemble
✔ Le résultat de l’analyse lexicale est aussi
utilisé pour la coloration syntaxique
✔ Pour décrire les grammaires des
analyseurs lexicaux et syntaxiques, on
utilise la Forme de Backus-Naur
10/109
Grammaire
BNF
✔ Backus Naur Form
✔ Notation permettant
de décrire les règles syntaxiques des
langages de programmation
✔ Défini lors de la création de Algol60
✔ Successeur du Fortran originalement créé
par John Backus
12/109
John Backus
1924 - 2007
Peter Naur
1928 - 2016
EBNF - syntaxe
✔ * répétition
✔ - absence
✔ , concaténation
✔ | choix
✔ = définition
✔ ; terminaison
✔ ‘a’ .. ‘z’ intervalle
13/109
✔ ´ terminal ambigu ´
✔ " terminal ambigu "
✔ (* commentaire *)
✔ ( groupe )
✔ [ groupe optionnel ]
✔ { groupe répété }
✔ ? séquence spéciale ?
EBNF - exemple
null = ' ' | 't' | 'n' | 'r';
number = ( '0'..'9' ) { '0'..'9' };
symbol = '(' | ')' | '+';
keyword = { 'a'..'b' | 'A'..'B' };
lexem = keyword | symbol | number | 
null;
lexemList = { lexem }
14/109
BNF - exercice
✔ Quelle est la grammaire du wkt ?
✔ POINT (10 20)
✔ POINT Z (17 15.5 14.7)
✔ MULTIPOINT((3.5 5.6), (4.8 10.5))
✔ MULTIPOINT Z( (3.5 5.6 4.7), ( 4.8 10.5 7))
15/109
EBNF - exercice
✔ MULTIPOINT Z ( (3.5 5.6 4.7 ), ( 4.8 10.5 7 ) )
16/109
MULTIPOINT
Keyword Dim? data
pointCoordList
pointCoord
coord
EBNF - réponse
multipoint = keyword dim? Data;
keyword = 'MULTIPOINT';
dim = 'Z' | 'M' | 'ZM';
data = '(' pcl ')';
pcl = pc { ',' pc };
pc = '(' number { ' ' number } ')';
number = [0..9] { [0..9] }
17/109
Attention destiné
au Lexer
Pourquoi cette
syntaxe ?
Railroad Diagram
✔ Propose une représentation graphique de la
grammaire
✔ http://www.bottlecaps.de/rr/ui
✔ Représente les séquences, les choix et les
boucles
✔ Remarque : opérateurs nécessaires et
suffisants
✔ cf : JinyParser
18/109
Railroad Diagram
19/109
sequence a b choix a | b
répétition 1-n a+
répétition 0-n a* optionnel a?
Railroad Diagram
20/109
répétition 1-n
optionel
[0-9]+ ( . [0-9]+ )?
Équivalences Kleene / EBNF
✔ Optionnel :
a? <=> [ a ] <=> a | ξ
✔ Répétition (0 .. n) :
a* <=> { a } <=> ( a | ξ ) +
✔ Répétition (1 .. n) :
a+ <=> a { a }
21/109
Exercice
✔ Donner des exemples de mots acceptables
pour :
22/109
Réponses
✔ aba, abb, abaaaa, abbaaaaa
✔ non acceptés : abbb, aaba, bab
✔ 0, 1, 50, 25.4, 29.7598
✔ non acceptés : .25, 2.2.2, 27.
23/109
Analyse Lexicale
Généralités
✔ But :
✔ Lire le code source
✔ Reconnaître les mots
✔ Distinguer les types de mots (chiffres,
identifiants, chaînes de caractères,
symboles, espaces)
✔ Entrée :
✔ Une liste de caractères
✔ Sortie :
✔ Une liste de mots typés (lexèmes)
25/109
Lexer - définition
26/109
s e t a = 7 * 3 + b
set keyword
space
a ident
= symbol
7 number
* symbol
3 number
+ symbol
b ident
Remarques
✔ Consommé par l’analyseur syntaxique
✔ Mais pas obligatoire (algorithmes
similaires entre lexer et parser)
✔ Utilise généralement un algorithme LL(1)
✔ Également utilisé lors de la coloration
syntaxique
27/109
void main() {
set a = 7 * 3 + b
}
Question ?
✔ Différence entre grammaire pour le lexer et
pour le parser
28/109
number :
addition :
Terminal / Non Terminal
✔ Et dit terminal ssi aucune règle n’existe pour
le transformer en autre chose
✔ Et dit non terminal ssi une règle existe (dés
qu’il existe un choix)
29/109
number :
addition :
T
T
NT
NT
NT
NT
Remarques
✔ Ces mots typés sont appelés Lexèmes ou
Tokens
✔ Types généralement utilisés :
✔ SPACE, COMMENT - /* */ n
✔ SYMBOL - ( ) { } + - * / %
✔ NUMBER, STRING
✔ KEYWORD – if, else, while, do
✔ IDENT – Test sur le type uniquement
30/109
Exercice
✔ Donner la définition d’un analyseur lexical
capable de parcourir ce script :
31/109
if (_var0 < 0.1) { /* test */
print ("too small")
} else {
_var0 += 1
}
Réponse
32/109
digit ::= [0­9]
alpha ::= [a­z] | [A­Z] | '_'
alphaNum ::= digit | alpha
character ::= alpha | num | Space
SPACE ::= ' ' | 'n' | 't'
COMMENT ::= '/*' character* '*/'
SYMBOL ::= '+='|'='|'+'|'('|')'|'{'|'}'
NUMBER ::= digit+ ('.' digit+)?
STRING ::= '"' character* '"'
KEYWORD ::= 'if' | 'then'
IDENT ::= alpha alphaNum*
L’ordre est il
important ?
Pourquoi pas
alphaNum+ ?Production d’un
lexème + type
33/109
digit alpha alphaNum character
SPACE COMMENT
NUMBER STRING
KEYWORD IDENT
SYMBOL
Lexème global
✔ Un programme est une liste de mots
34/109
Lexem ::= COMMENT | SYMBOL | NUMBER |
          STRING | KEYWORD | IDENT
SourceCode ::= Lexem? (SPACE Lexem)*
Lexem
SourceCode
Algorithme LL(0)
Algorithme LL(0)
✔ Pour transformer la chaîne de caractère en
liste de lexèmes, il faut :
✔ Lire les caractères uns a uns
✔ De gauche à droite
✔ Déterminer le type de production
✔ Stocker le résultat dans une liste
36/109
LL(0) Recursive descent
parser
function testA() {
if (current == "a") return true;
return false;
}
function consumeA() {
// do stuffs
next()
}
37/109
abbaaaaa
consumed
Implémentation typique
sequence
function sequence() {
if (testA()) consumeA()
else return false
if (testB()) consumeB()
else return false
  return true
}
38/109
Implémentation typique
39/109
choix
function choice() {
if (testA()) consumeA()
else if (testB()) consumeB()
else return false
  return true
}
Implémentation typique
40/109
optionnel :
function optional() {
if (testA()) consumeA()
return true
}
Implémentation typique
répétition + :
function repeatOneOrMore() {
if (!testA()) return false
do {
consumeA()
} while (testA())
return true
}
41/109
Implémentation typique
42/109
répétition * :
function repeatZeroOrMore() {
while (testA()) {
consumeA()
}
  return true
}
Algorithme LL(0)
✔ Left to Right
✔ Left most derivation
✔ L’élément de gauche détermine quelle
règle grammaticale appliquer
✔ Look ahead de 0
✔ L’algorithme ne teste que le caractère
courant
✔ Algorithme typiquement utilisé pour
l’analyseur lexical
✔ Implémentation Recursive Descent Parser
43/109
Exemple
44/109
number :
function parseNumChar() {
if (!testNum()) 
      return false
do {
consume()
} while (testNum)
   return false
}
function parseNumber() {
parseNumChar()
if (testDot()) {
consume()
parseNumChar()
}
}
Répétition +
Optionnel
Limitations
✔ Le premier symbole (Left most derivation)
est déterminant pour la production
✔ Convient pour le Basic, le Pascal, Le LISP ou
l’analyse lexicale
✔ Pourquoi les identifiants doivent
commencer par une lettre (C like, Python,
Pascal, Basic ...)
✔ String str2 = « myString » est valide
✔ String 2dStr = « myString » ne l’est pas !
45/109
Limitations - solution
✔ Pour augmenter le nombre de grammaire
reconnus on peu augmenter le “look
ahead”
✔ Avant la production on regarde les
éléments suivant
✔ L’analyseur LL(k)
✔ k détermine le nombre d’éléments à
regarder
✔ LL(0) est un cas particulier du LL(k)
✔ LL(*) lorsque k est illimité (pré-analyse sans
production) 46/109
LL(k)
47/109
 2dStr = “Hello”
look ahead
✔ Un look ahead de 2 permettrait de préfixer
les identifiants avec un chiffre
✔ Ainsi de distinguer un identifiant d’un
nombre de manière certaine
✔ Ne fonctionne plus si le nombre est plus
grand : 27dString
✔ Une solution ?
LL(*)
48/109
 2dStr = “Hello”
look ahead
✔ Un look ahead infini permet de déterminer
à coup sûr de la grammaire qui va suivre
✔ Intervient lors d’un choix entre deux
productions
✔ Algorithme Backtrack (parcours
récursivement la structure)
✔ A suivre ….
Analyse Syntaxique
Généralités
✔ But :
✔ Lire les lexèmes
✔ Reconnaître les grammaires
✔ Produire un AST (arbre de syntaxe)
✔ Entrée :
✔ Une liste de lexèmes
✔ Sortie :
✔ Un AST, arbre représentant le programme
50/109
Parser - définition
51/109
set keyword
space
a ident
= symbol
7 number
* symbol
3 number
+ symbol
b ident
77
**
33
++
bb
==
aa
setset
Remarques
✔ Consomme le résultat de l’analyseur lexical
✔ Utilise généralement un algorithme plus
complexe que le LL(0)
✔ LL(0) utilisé par BASIC, PASCAL, MsDOS
✔ Consommé par l’analyseur sémantique
et/ou le codegen
✔ Algorithme Récursif : Recursive Descent
Parser
52/109
Algorithme LL(1)
✔ A → ( B )
✔ B → AB
✔ B → ε
✔ Exemple : ( ( ) ( ) )
53/109
( ) $
A A → (B) - -
B B → AB B → ε B → ε
AA
(( BB ))
AA
(( BB ))
εε
B
)
$
BB
AA
(( BB ))
εε
BB
εε
✔ A → ( B )
✔ B → AB
✔ B → ε
✔ Exemple : ( ( ) ( ) )
54/109
Démo table
( ) $
A A → (B) - -
B B → AB B → ε B → ε
AA
(( BB ))
B
)
$
55/109
✔ A → ( B )
✔ B → AB
✔ B → ε
✔ Exemple : ( ( ) ( ) ) 55/109
Démo récursion
AA
(( BB ))
C1
$
function parseA() {
parse (’(‘)
parseB() // C1
parse (’)‘)
}
function parseB() {
if (’(‘) {
parseA() // C2
parseB() // C3
} else return true
}
Remarques
✔ Tout algorithme récursif peut-être converti
en machine à pile
✔ Et réciproquement
✔ Dans un algorithme récursif, on utilise la
pile d’appel des fonctions
56/109
Récursivité
✔ Exemple ”bien parenthésé”
57/109
if (a == 0) {
if (b == 0) {
if (c == 0) {
}
}
}
Récursivité
58/109
if (a == 0) {
if (b == 0) {
}
}
((
cndcnd
ifif
exex )) {{
stmtstmt
}}
((
cndcnd
ifif
exex (( {{
stmtstmt
exex }}
Récursivité
✔ Récursif dans les cas de : structures de
contrôle, expressions arithmétiques, blocs
de code, appels de fonctions etc….
59/109
Exercice
✔ Donner la définition d’un analyseur
syntaxique capable d’interpréter ce script :
60/109
if (_var0 < 0.1) { /* test */
print ("too small")
} else {
_var0 += 1
}
Réponse
61/109
If ::= 'if' '(' Expr ')' Statement ('else' Statement)?
Parameter ::= Call | Expr
Call ::= Ident '(' (Parameter (',' Parameter)* )? ')'
Statement ::= If | Call | Expr | Block
Block ::= '{' Statement* '}'
Recursif
Pourquoi ?
Récursif
62/109
If
Parameter
Call
Block
Statement
Algorithmes LL(k) et LL(*)
Limitations
✔ Rappel : Les algorithmes LL(0) sont limités
✔ Le symbole le plus à gauche (Left most
dérivation) est déterminant pour la
production
✔ Convient à la majeur partie des structures
(if, set/let, while, do)
✔ Mais pas pour l’arithmétique !
64/109
LL1
65/109
10 + 10
✔ L’analyseur n’est pas capable de savoir, à
cet endroit là :
✔ S’il est en présence d’un chiffre seul
✔ Ou si ce chiffre fait partie d’une opération
✔ Grammaire ambiguë
✔ S → n
✔ S → S + S
✔ ici S commence par un non terminal )
Impossible !
S → S + S
S → n
66/109
function parseSum() {
try {
parseSum()
if (testPlus()) consumePlus()
return false
parseSum()
} catch {
if (testNumber()) consumeNumber()
return false
}
   return true
}
Pas mieux !
S → n
S → S + S
67/109
function parseSum() {
if (testNumber()) consumeNumber()
else {
parseSum()
parsePlus()
parseSum()
}
}
Solution 1 : Modifier le langage
68/109
( + 10 10 )
✔ Cas du LISP (John McCarthy 1958)
✔ Pas d’ambiguïté, l’opération commence par
l’opérateur
✔ S → ( + S S )
✔ S → n
Mieux !
S → + S S
S → n
69/109
function parseSum() {
if (testPlus()) {
consumePlus()
parseSum()
parseSum()
} else if (testNumber())
consumeNumber()
else return false
return true
}
Solution 2 : Modifier la grammaire
70/109
10 + 10
✔ S → n F
✔ F → + S
✔ F → ε
✔ Suppression de la récursivité à gauche
Mieux !
S → n F
F → + S
F → ε
71/109
function parseSum() {
if (testNumber()) consumeNumber()
else return false
if (testPlus()) {
consumePlus()
parseSum()
}
   return true
}
Cas Général
✔ Suppression de la récursivité à gauche
✔ Immédiate : A → Aα, α ∈ (T ∪ N)+
✔ Générale : A → *Aα, α ∈ (T ∪ N)+
✔ Il est possible de supprimer les deux cas
par transformation de la grammaire
72/109
Récursivité immédiate
✔ On remplace les règles de la forme :
✔ X → Xα1
| … | Xαn
| β1
| … | βm
✔ Par les règles :
✔ X → β1
X’ | … | βm
X’
✔ X’ → α1
X’ | … | αn
X’ | ε
73/109
Exercice
✔ Supprimer la récursivité à gauche de :
✔ E → E + T | T
T → T * F | F
F → i | ( E )
✔ X → Xα1
| … | Xαn
| β1
| … | βm
✔ X → β1
X’ | … | βm
X’
✔ X’ → α1
X’ | … | αn
X’ | ε
74/109
Solution
✔ E → T E’
E’ → + T E’ | ε ( ou E’ → + E | ε)
T → F T’
T’ → * F T’ | ε ( ou T’ → + T | ε)
F → i | ( E )
✔ X → β1
X’ | … | βm
X’
X’ → α1
X’ | … | αn
X’ | ε
75/109
Précédence des opérateurs
✔ E → E + T | T
T → T * F | F
F → ( E ) | i
✔ ex : ( 3 + 7 * 2 ) + 4
E→E+T
E→T, T→F, F→(E)
E→E+T, T→T*F
76/109
Solution 3 : Lookahead
77/109
10 + 10
lookahead
✔ Un lookahead de 2 permettrait de définir la
production ( chiffre ou addition )
✔ Lorsque l’algorithme est face à un choix de
production, il lance une prédiction
✔ S → n ( + S ) *
Mieux !
✔ S → n ( + S )*
78/109
function parseSum() {
if (!testNumber()) return
moveForewardLL()
if (!testPlus()) return
moveBackwardLL()
parseNumber()
parsePlus()
parseSum()
}
10 + 10
lookahead
Algorithmes LL(k), LL(*) et LR
Solution 3 : Lookahead
80/109
10 + 10
lookahead
✔ Un look ahead de 2 permettrait de définir
la production ( chiffre ou addition )
✔ Lorsque l’algorithme est face à un choix de
production, il lance une prédiction
✔ S → n ( + S ) *
Mieux !
✔ S → n ( + S )*
81/109
function parseSum() {
if (!testNumber()) return
moveForewardLL()
if (!testPlus()) return
moveBackwardLL()
parseNumber()
parsePlus()
parseSum()
}
10 + 10
lookahead
LL(k) et LL(*)
✔ L’algorithme LL(0) est un cas particulier de
LL(k)
✔ k = 0, pas de look ahead
✔ LL(k) est un cas particulier de LL(*)
✔ k est fini alors que * est infini
✔ antLR v1 → LL(1)
✔ JavaC → LL(k)
✔ antLR v3 → LL(*)
82/109
Prédictibilité
✔ Principe : lors
d’une décision,
l’algorithme lance
une prédiction
✔ c’est-à-dire un
algorithme
récursif qui ne
consomme pas
et ne produit pas
83/109
function predictSum() {
if (testNumber()) {
moveForeward()
if (testPlus()) {
moveForeward()
if (predictSum()) 
return true
moveBackward()
}
moveBackward()
}
return false
}
Limitations
✔ L’algorithme LL(*) refuse toujours la
récursivité gauche.
✔ De plus sa complexité est exponentielle
84/109
Complexité
85/109
if (a == 0) {
if (b == 0) {
if (c == 0) {
}
}
}
((
cndcnd
ifif
exex )) {{
stmtstmt
}}
((
cndcnd
ifif
exex (( {{
stmtstmt
ifif }}
exex
Solution : Packrat
✔ Utiliser un cache.
✔ Pour chaque décision, stocker une paire
clé (position), valeur (décision)
✔ Utiliser le cache lors du prochain passage
✔ Garantie que l’évaluation n’aura lieu qu’une
seule fois
✔ Algorithme Packrat
✔ Complexité presque linéaire
86/109
Analyser LR
Généralités
✔ Inventé par Donald Knuth en Juillet 1965
✔ Left To Right, Right most derivation
✔ LL : Approche Top Down
✔ LR : Approche Bottom Up
88/109
Analyseur LR
✔ Inventé par Donald Knuth
✔ en Juillet 1965
✔ Left To Right, Right most derivation
✔ LL : Approche Top Down
✔ LR : Approche Bottom Up
89/109
Donald Knuth
1938
Analyseur LR
✔ 2 structures :
✔ Flot d’entré
✔ Pile
✔ 4 opérations :
✔ Shift : transfert du flot d’entrée vers la pile
✔ Reduce : On reconnai sur le sommet de la
pile une partie droite d’une production,
on la remplace par la partie gauche
✔ Erreur : Arrêt et signalement d’une erreur
✔ Accept : Arrêt, phrase reconnu
90/109
Exemple : SLR
✔ Simple LR parser ou LR(0)
✔ Soit le flot d’entrée : 10 + 10 + 10
✔ Et la grammaire :
E → E + T | T
T → n
91/109
92/109
10 + 10 + 10 shift
10 + 10 + 10 reduce
T + 10 + 10 reduce
E + 10 + 10 shift
E + 10 + 10 shift
E + 10 + 10 reduce
E + T + 10 reduce
E + 10 shift
E + 10 shift
E + 10 reduce
E + T reduce
E accept
E → E + T | T
T → n
LALR
✔ LALR – Look-Ahead LR Parser
✔ Analyseur avec anticipation
✔ Permet un ensemble de grammaire plus
grand
✔ Fonctionnement de YaCC
✔ Permet de résoudre l’ambiguité :
✔ S → L• = R ( Curseur • )
✔ R → L•
93/109
94/109
10 + 10 + 10 shift
10 + 10 + 10 reduce
T + 10 + 10 shift
T + 10 + 10 shift
T + 10 + 10 reduce
T + T + 10 shift (*)
T + T + 10 shift
T + T + 10 reduce
T + T + T reduce (*)
T + T + E reduce
T + E reduce
E accept
E → E + T | T
T → n
Compilateurs de compilateurs
✔ Les analyseurs LR sont trop complexes à
écrire à la main
✔ Généralement construits par des
générateurs d’analyseur (compilateurs de
compilateurs)
✔ Crée une table d’analyse
✔ Action, les actions à faire en fonction des
symboles rencontrés
✔ Transition, les branchements
95/109
Les algorithmes
✔ Deux grandes familles d’algorithmes :
✔ LL → LL(0), LL(k), LL(*), Packrat, PEG (Parsing
Expression Grammar)
✔ LR → SLR (Simple LR), LALR (Look Ahead LR),
GLR
96/109
Arbre syntaxique abstrait (AST)
AST : Arbre syntaxique
✔ En : Abstract Syntax Tree
✔ Arbre logique qui représente la structure
du programme
✔ Ses nœuds sont des opérateurs et ses
feuilles des opérandes (variables ou
constantes)
✔ Une production grammaticale produit un
nœud de l’arbre
98/109
Exemple
99/109
7 * (8 + 3) + 5
77
**
88
++
33
++
55
Production
Expression E
Terme T
E → E * E
E → E + E
E → T
T → ( E )
T → int
100/109
7 * (8 + 3)
77
**
88 33
++
Démo : recursive-descent-parser2.al
AST - Parcours
✔ CodeGen arithmétique → LISP
✔ 7 * (8 + 3) + 5
✔ LISP :
✔ (+ (* 7 (+ 8 3)) 5)
✔ Cf : Parcours d’arbres
✔ Cf : Demo Algo
101/109
77
**
88
++
33
++
55
Pile
AST - Parcours
102/109
77
**
88
++
33
++
55
+
3 3 * +
8 8 8 11 11 5
7 7 7 7 7 7 77 77 82
Temps
103/109
while b   0≠
  if a > b
    a := a − b
  else
    b := b − a
return a
Grammaires ambiguës
✔ Définition : une grammaire ambiguë c’est
lorsque qu’une grammaire peut engendrer
deux arbres différents
✔ Exemple : if - if – else (à quel if correspond
le else)
✔ Solution : le Parsing Expression Grammar
✔ Dans le cas d’une grammaire ambiguë, le
PEG va choisir la première qui correspond
✔ En réalité proche du programme et non
de la théorie
104/109
Précédence
E → E * E
E → E + E
E → T
T → ( E )
T → int
105/109
7 + 8 * 3
77
++
88 33
**
Précédence
M → A * M
A → T + A
T → ( E )
T → int
106/109
7 + 8 * 3
77
++
88
33
**
Pourquoi un AST ?
✔ L’interprétation directe oblige de ré-
analyser lors de chaque itération
✔ Offre l’opportunité d’optimisations (analyse
sémantique)
✔ Offre l’opportunité de vérifications
✔ Peut être réutilisé
✔ Plusieurs cibles
✔ Compilation
✔ Interprétation
✔ Traduction
107/109
Et après
108/109
ASTAST Optimisation
CompilationCompilation
InterprétationInterprétation TraductionTraduction
CodeGen
Analyse
Sémantique
Merci de votre attention

Contenu connexe

Tendances

Correction examen-java-avancé-1
Correction examen-java-avancé-1Correction examen-java-avancé-1
Correction examen-java-avancé-1vangogue
 
Techniques et-methodes-calcul-integral-mr-anis-ben-ali
Techniques et-methodes-calcul-integral-mr-anis-ben-aliTechniques et-methodes-calcul-integral-mr-anis-ben-ali
Techniques et-methodes-calcul-integral-mr-anis-ben-alim.a bensaaoud
 
Chapitre 2 complexité
Chapitre 2 complexitéChapitre 2 complexité
Chapitre 2 complexitéSana Aroussi
 
Travaux Dirigés : Algorithmique et Structure de Données
Travaux Dirigés : Algorithmique et Structure de DonnéesTravaux Dirigés : Algorithmique et Structure de Données
Travaux Dirigés : Algorithmique et Structure de DonnéesAnass41
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite completChahrawoods Dmz
 
Chapitre2_Partie1.pdf
Chapitre2_Partie1.pdfChapitre2_Partie1.pdf
Chapitre2_Partie1.pdfMbarkiIsraa
 
POO Java Chapitre 6 Exceptions
POO Java  Chapitre 6 ExceptionsPOO Java  Chapitre 6 Exceptions
POO Java Chapitre 6 ExceptionsMouna Torjmen
 
Introduction a la compilation Analyse Syntaxique - C3
Introduction a la compilation  Analyse Syntaxique - C3Introduction a la compilation  Analyse Syntaxique - C3
Introduction a la compilation Analyse Syntaxique - C3Beligh HAMDI
 
Examen principal - Fondement Multimedia - correction
Examen principal - Fondement Multimedia - correctionExamen principal - Fondement Multimedia - correction
Examen principal - Fondement Multimedia - correctionInes Ouaz
 
Chapitre i introduction et motivations
Chapitre i introduction et motivationsChapitre i introduction et motivations
Chapitre i introduction et motivationsSana Aroussi
 
Utilisation de la simulation dans le domaine hospitalier
Utilisation de la simulation dans le domaine hospitalierUtilisation de la simulation dans le domaine hospitalier
Utilisation de la simulation dans le domaine hospitalierAlvaro Gil
 

Tendances (20)

Correction examen-java-avancé-1
Correction examen-java-avancé-1Correction examen-java-avancé-1
Correction examen-java-avancé-1
 
Techniques et-methodes-calcul-integral-mr-anis-ben-ali
Techniques et-methodes-calcul-integral-mr-anis-ben-aliTechniques et-methodes-calcul-integral-mr-anis-ben-ali
Techniques et-methodes-calcul-integral-mr-anis-ben-ali
 
Chapitre 2 complexité
Chapitre 2 complexitéChapitre 2 complexité
Chapitre 2 complexité
 
Travaux Dirigés : Algorithmique et Structure de Données
Travaux Dirigés : Algorithmique et Structure de DonnéesTravaux Dirigés : Algorithmique et Structure de Données
Travaux Dirigés : Algorithmique et Structure de Données
 
Cours algorithmique et complexite complet
Cours algorithmique et complexite completCours algorithmique et complexite complet
Cours algorithmique et complexite complet
 
Chapitre2_Partie1.pdf
Chapitre2_Partie1.pdfChapitre2_Partie1.pdf
Chapitre2_Partie1.pdf
 
POO Java Chapitre 6 Exceptions
POO Java  Chapitre 6 ExceptionsPOO Java  Chapitre 6 Exceptions
POO Java Chapitre 6 Exceptions
 
Diagramme d'activité en UML
Diagramme d'activité en UMLDiagramme d'activité en UML
Diagramme d'activité en UML
 
COURS_PYTHON_22.ppt
COURS_PYTHON_22.pptCOURS_PYTHON_22.ppt
COURS_PYTHON_22.ppt
 
Introduction a la compilation Analyse Syntaxique - C3
Introduction a la compilation  Analyse Syntaxique - C3Introduction a la compilation  Analyse Syntaxique - C3
Introduction a la compilation Analyse Syntaxique - C3
 
Langage vhdl
Langage vhdlLangage vhdl
Langage vhdl
 
Examen principal - Fondement Multimedia - correction
Examen principal - Fondement Multimedia - correctionExamen principal - Fondement Multimedia - correction
Examen principal - Fondement Multimedia - correction
 
Ch 01 poo
Ch 01 pooCh 01 poo
Ch 01 poo
 
Chapitre i introduction et motivations
Chapitre i introduction et motivationsChapitre i introduction et motivations
Chapitre i introduction et motivations
 
TP C++ : Correction
TP C++ : CorrectionTP C++ : Correction
TP C++ : Correction
 
Introduction à Python
Introduction à PythonIntroduction à Python
Introduction à Python
 
Ordonnancement
OrdonnancementOrdonnancement
Ordonnancement
 
Cours de c
Cours de cCours de c
Cours de c
 
Cours.langage c
Cours.langage cCours.langage c
Cours.langage c
 
Utilisation de la simulation dans le domaine hospitalier
Utilisation de la simulation dans le domaine hospitalierUtilisation de la simulation dans le domaine hospitalier
Utilisation de la simulation dans le domaine hospitalier
 

Similaire à Théorie des langages - 01 - Compilation

ALF 3 - Expressions régulières et Lexer
ALF 3 - Expressions régulières et Lexer ALF 3 - Expressions régulières et Lexer
ALF 3 - Expressions régulières et Lexer Alexandru Radovici
 
Algorithmique programmation2018
Algorithmique programmation2018Algorithmique programmation2018
Algorithmique programmation2018salah fenni
 
cour de compilation
cour de compilation cour de compilation
cour de compilation Ens Kouba
 
cour informatique niveau3 programmation en Python.pdf
cour informatique niveau3 programmation en  Python.pdfcour informatique niveau3 programmation en  Python.pdf
cour informatique niveau3 programmation en Python.pdfNanchi6
 
Un compilateur... comment ça marche?
Un compilateur... comment ça marche?Un compilateur... comment ça marche?
Un compilateur... comment ça marche?Dinesh Bolkensteyn
 
Développement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulièresDéveloppement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulièresECAM Brussels Engineering School
 
Mat lab1
Mat lab1Mat lab1
Mat lab1fouadDD
 
Jouer avec des analyseurs syntaxiques
Jouer avec des analyseurs syntaxiquesJouer avec des analyseurs syntaxiques
Jouer avec des analyseurs syntaxiquesEric De la Clergerie
 
Théorie des langages - TP - WellKnownText
Théorie des langages - TP  - WellKnownTextThéorie des langages - TP  - WellKnownText
Théorie des langages - TP - WellKnownTextYann Caron
 
Python avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesPython avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesECAM Brussels Engineering School
 
Redis - (nosqlfr meetup #2)
Redis - (nosqlfr meetup #2) Redis - (nosqlfr meetup #2)
Redis - (nosqlfr meetup #2) Frank Denis
 

Similaire à Théorie des langages - 01 - Compilation (20)

ALF 8 - Generation du code
ALF 8 - Generation du codeALF 8 - Generation du code
ALF 8 - Generation du code
 
C++ 11/14
C++ 11/14C++ 11/14
C++ 11/14
 
ALF 3 - Expressions régulières et Lexer
ALF 3 - Expressions régulières et Lexer ALF 3 - Expressions régulières et Lexer
ALF 3 - Expressions régulières et Lexer
 
Algorithmique programmation2018
Algorithmique programmation2018Algorithmique programmation2018
Algorithmique programmation2018
 
cour de compilation
cour de compilation cour de compilation
cour de compilation
 
Google Developer Group (GDG) Aix-Marseille #1 (27/08/2018)
Google Developer Group (GDG) Aix-Marseille #1 (27/08/2018)Google Developer Group (GDG) Aix-Marseille #1 (27/08/2018)
Google Developer Group (GDG) Aix-Marseille #1 (27/08/2018)
 
cour informatique niveau3 programmation en Python.pdf
cour informatique niveau3 programmation en  Python.pdfcour informatique niveau3 programmation en  Python.pdf
cour informatique niveau3 programmation en Python.pdf
 
INF355_Lecon2.pdf
INF355_Lecon2.pdfINF355_Lecon2.pdf
INF355_Lecon2.pdf
 
Un compilateur... comment ça marche?
Un compilateur... comment ça marche?Un compilateur... comment ça marche?
Un compilateur... comment ça marche?
 
Développement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulièresDéveloppement informatique : Chaines de caractères et expressions regulières
Développement informatique : Chaines de caractères et expressions regulières
 
TAD (1).pptx
TAD (1).pptxTAD (1).pptx
TAD (1).pptx
 
Cours de Matlab
Cours de MatlabCours de Matlab
Cours de Matlab
 
Mat lab1
Mat lab1Mat lab1
Mat lab1
 
Jouer avec des analyseurs syntaxiques
Jouer avec des analyseurs syntaxiquesJouer avec des analyseurs syntaxiques
Jouer avec des analyseurs syntaxiques
 
ALF 4 - Grammaires
ALF 4 - GrammairesALF 4 - Grammaires
ALF 4 - Grammaires
 
Implementing a key/value store
Implementing a key/value storeImplementing a key/value store
Implementing a key/value store
 
Théorie des langages - TP - WellKnownText
Théorie des langages - TP  - WellKnownTextThéorie des langages - TP  - WellKnownText
Théorie des langages - TP - WellKnownText
 
Python avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de donnéesPython avancé : Ensemble, dictionnaire et base de données
Python avancé : Ensemble, dictionnaire et base de données
 
Redis - (nosqlfr meetup #2)
Redis - (nosqlfr meetup #2) Redis - (nosqlfr meetup #2)
Redis - (nosqlfr meetup #2)
 
TP5_2020.pdf
TP5_2020.pdfTP5_2020.pdf
TP5_2020.pdf
 

Plus de Yann Caron

Théorie des langages - 04 Théorie des langages
Théorie des langages - 04 Théorie des langagesThéorie des langages - 04 Théorie des langages
Théorie des langages - 04 Théorie des langagesYann Caron
 
Théorie des langages - 03 - Principes et paradigmes
Théorie des langages - 03 - Principes et paradigmesThéorie des langages - 03 - Principes et paradigmes
Théorie des langages - 03 - Principes et paradigmesYann Caron
 
Théorie des langages - 02 - Code gen
Théorie des langages - 02 - Code genThéorie des langages - 02 - Code gen
Théorie des langages - 02 - Code genYann Caron
 
Théorie des langages - 01.1 - Parcours d'arbres
Théorie des langages - 01.1 - Parcours d'arbresThéorie des langages - 01.1 - Parcours d'arbres
Théorie des langages - 01.1 - Parcours d'arbresYann Caron
 
Théorie des langages - 00 - Introduction
Théorie des langages - 00 - IntroductionThéorie des langages - 00 - Introduction
Théorie des langages - 00 - IntroductionYann Caron
 
Algea - 04 - conclusion
Algea - 04 - conclusionAlgea - 04 - conclusion
Algea - 04 - conclusionYann Caron
 
Algea - 03 - ennemis
Algea - 03 - ennemisAlgea - 03 - ennemis
Algea - 03 - ennemisYann Caron
 
Algea - 02 - gemmes
Algea - 02 - gemmesAlgea - 02 - gemmes
Algea - 02 - gemmesYann Caron
 
Algea - 01 - hero
Algea - 01 - heroAlgea - 01 - hero
Algea - 01 - heroYann Caron
 
ALGEA - 00 - introduction
ALGEA - 00 - introductionALGEA - 00 - introduction
ALGEA - 00 - introductionYann Caron
 
Programmation Android - Tp2 Travaux pratiques - Geomatique
Programmation Android - Tp2 Travaux pratiques - GeomatiqueProgrammation Android - Tp2 Travaux pratiques - Geomatique
Programmation Android - Tp2 Travaux pratiques - GeomatiqueYann Caron
 
Programmation Android - 10 - Spatialite
Programmation Android - 10 - SpatialiteProgrammation Android - 10 - Spatialite
Programmation Android - 10 - SpatialiteYann Caron
 
Programmation Android - 09 - Web services
Programmation Android - 09 - Web servicesProgrammation Android - 09 - Web services
Programmation Android - 09 - Web servicesYann Caron
 
Programmation Android - 08 - Android debug bridge
Programmation Android - 08 - Android debug bridgeProgrammation Android - 08 - Android debug bridge
Programmation Android - 08 - Android debug bridgeYann Caron
 
Programmation Android 07 - Techniques avancées
Programmation Android 07 - Techniques avancéesProgrammation Android 07 - Techniques avancées
Programmation Android 07 - Techniques avancéesYann Caron
 
Programmation Android - 06 - Publication
Programmation Android - 06 - PublicationProgrammation Android - 06 - Publication
Programmation Android - 06 - PublicationYann Caron
 
Programmation Android - 05 - Google map
Programmation Android - 05 - Google mapProgrammation Android - 05 - Google map
Programmation Android - 05 - Google mapYann Caron
 
Programmation Android - 04 - Databases
Programmation Android - 04 - DatabasesProgrammation Android - 04 - Databases
Programmation Android - 04 - DatabasesYann Caron
 
Programmation Android - 03 - IHM bases
Programmation Android - 03 - IHM basesProgrammation Android - 03 - IHM bases
Programmation Android - 03 - IHM basesYann Caron
 
Programmation Android - 02 - Android
Programmation Android - 02 - AndroidProgrammation Android - 02 - Android
Programmation Android - 02 - AndroidYann Caron
 

Plus de Yann Caron (20)

Théorie des langages - 04 Théorie des langages
Théorie des langages - 04 Théorie des langagesThéorie des langages - 04 Théorie des langages
Théorie des langages - 04 Théorie des langages
 
Théorie des langages - 03 - Principes et paradigmes
Théorie des langages - 03 - Principes et paradigmesThéorie des langages - 03 - Principes et paradigmes
Théorie des langages - 03 - Principes et paradigmes
 
Théorie des langages - 02 - Code gen
Théorie des langages - 02 - Code genThéorie des langages - 02 - Code gen
Théorie des langages - 02 - Code gen
 
Théorie des langages - 01.1 - Parcours d'arbres
Théorie des langages - 01.1 - Parcours d'arbresThéorie des langages - 01.1 - Parcours d'arbres
Théorie des langages - 01.1 - Parcours d'arbres
 
Théorie des langages - 00 - Introduction
Théorie des langages - 00 - IntroductionThéorie des langages - 00 - Introduction
Théorie des langages - 00 - Introduction
 
Algea - 04 - conclusion
Algea - 04 - conclusionAlgea - 04 - conclusion
Algea - 04 - conclusion
 
Algea - 03 - ennemis
Algea - 03 - ennemisAlgea - 03 - ennemis
Algea - 03 - ennemis
 
Algea - 02 - gemmes
Algea - 02 - gemmesAlgea - 02 - gemmes
Algea - 02 - gemmes
 
Algea - 01 - hero
Algea - 01 - heroAlgea - 01 - hero
Algea - 01 - hero
 
ALGEA - 00 - introduction
ALGEA - 00 - introductionALGEA - 00 - introduction
ALGEA - 00 - introduction
 
Programmation Android - Tp2 Travaux pratiques - Geomatique
Programmation Android - Tp2 Travaux pratiques - GeomatiqueProgrammation Android - Tp2 Travaux pratiques - Geomatique
Programmation Android - Tp2 Travaux pratiques - Geomatique
 
Programmation Android - 10 - Spatialite
Programmation Android - 10 - SpatialiteProgrammation Android - 10 - Spatialite
Programmation Android - 10 - Spatialite
 
Programmation Android - 09 - Web services
Programmation Android - 09 - Web servicesProgrammation Android - 09 - Web services
Programmation Android - 09 - Web services
 
Programmation Android - 08 - Android debug bridge
Programmation Android - 08 - Android debug bridgeProgrammation Android - 08 - Android debug bridge
Programmation Android - 08 - Android debug bridge
 
Programmation Android 07 - Techniques avancées
Programmation Android 07 - Techniques avancéesProgrammation Android 07 - Techniques avancées
Programmation Android 07 - Techniques avancées
 
Programmation Android - 06 - Publication
Programmation Android - 06 - PublicationProgrammation Android - 06 - Publication
Programmation Android - 06 - Publication
 
Programmation Android - 05 - Google map
Programmation Android - 05 - Google mapProgrammation Android - 05 - Google map
Programmation Android - 05 - Google map
 
Programmation Android - 04 - Databases
Programmation Android - 04 - DatabasesProgrammation Android - 04 - Databases
Programmation Android - 04 - Databases
 
Programmation Android - 03 - IHM bases
Programmation Android - 03 - IHM basesProgrammation Android - 03 - IHM bases
Programmation Android - 03 - IHM bases
 
Programmation Android - 02 - Android
Programmation Android - 02 - AndroidProgrammation Android - 02 - Android
Programmation Android - 02 - Android
 

Théorie des langages - 01 - Compilation