10 octobre 2007 Cours de compilation 6 - Intranet 1
Cours de compilationCours de compilation
Analyse sémantiqueAnalyse sémantique
Environnement d’exécutionEnvironnement d’exécution
10 octobre 2007 Cours de compilation 6 - Intranet 2
Les grandes lignes du coursLes grandes lignes du cours
•Définitions de baseDéfinitions de base•Composition de compilateursComposition de compilateurs•L’environnement d’un compilateurL’environnement d’un compilateur•Evaluation partielle et compilationEvaluation partielle et compilation•Analyses lexicales et syntaxiquesAnalyses lexicales et syntaxiques•Techniques d’analyse descendantesTechniques d’analyse descendantes•Techniques d’analyse ascendantesTechniques d’analyse ascendantes•YACCYACC•Analyse sémantiqueAnalyse sémantique•Environnement d’exécutionEnvironnement d’exécution•Génération de codeGénération de code•Optimisation de codeOptimisation de code
10 octobre 2007 Cours de compilation 6 - Intranet 3
L ‘ A N A L Y S EL ‘ A N A L Y S E
S E M A N T I Q U ES E M A N T I Q U E
10 octobre 2007 Cours de compilation 6 - Intranet 4
V E R I F I C A T I O NV E R I F I C A T I O N
D E SD E S
T Y P E ST Y P E S
10 octobre 2007 Cours de compilation 6 - Intranet 5
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----• Elle est faite en même temps que les Elle est faite en même temps que les
analyses lexicales et syntaxiques !analyses lexicales et syntaxiques !
10 octobre 2007 Cours de compilation 6 - Intranet 6
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----• Elle est faite en même temps que les Elle est faite en même temps que les
analyses lexicales et syntaxiques !analyses lexicales et syntaxiques !
• Il faut donc que tout soit déclaré avant Il faut donc que tout soit déclaré avant d’être utilisé :d’être utilisé :
– Déclaration avant l’utilisation !Déclaration avant l’utilisation !
10 octobre 2007 Cours de compilation 6 - Intranet 7
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----• Elle est faite en même temps que les Elle est faite en même temps que les
analyses lexicales et syntaxiques !analyses lexicales et syntaxiques !
• Il faut donc que tout soit déclaré avant Il faut donc que tout soit déclaré avant d’être utilisé :d’être utilisé :
– Déclaration avant l’utilisation !Déclaration avant l’utilisation !
• Les seuls problèmes :Les seuls problèmes :
– Les procédures mutuellement récursives !Les procédures mutuellement récursives !
– Les types récursifs !Les types récursifs !
10 octobre 2007 Cours de compilation 6 - Intranet 8
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----
proc f ( . . . )proc f ( . . . )
{{
gg ( . . . ); ( . . . );
}}
proc g ( . . . )proc g ( . . . )
{{
ff ( . . . ); ( . . . );
}}
10 octobre 2007 Cours de compilation 6 - Intranet 9
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----
proc f ( . . . )proc f ( . . . )
{{
gg ( . . . ); ( . . . );
}}
proc g ( . . . )proc g ( . . . )
{{
ff ( . . . ); ( . . . );
}}
10 octobre 2007 Cours de compilation 6 - Intranet 10
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----proc g ( . . . ) ;proc g ( . . . ) ;
proc f ( . . . )proc f ( . . . )
{{
gg ( . . . ); ( . . . );
}}
proc g ( . . . )proc g ( . . . )
{{
ff ( . . . ); ( . . . );
}}
Il faut unIl faut unprototypeprototypepour g ! ! !pour g ! ! !
10 octobre 2007 Cours de compilation 6 - Intranet 11
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----proc g ( . . . ) ;proc g ( . . . ) ;
proc f ( . . . ) ;proc f ( . . . ) ;
proc f ( . . . )proc f ( . . . )
{{
gg ( . . . ); ( . . . );
}}
proc g ( . . . )proc g ( . . . )
{{
ff ( . . . ); ( . . . );
}}
Il faut unIl faut unprototypeprototypepour g ! ! !pour g ! ! !
Nous donnonsNous donnonstous lestous lesprototypes ! ! !prototypes ! ! !
10 octobre 2007 Cours de compilation 6 - Intranet 12
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----• Les types récursifs en Pascal :Les types récursifs en Pascal :
type ptr_arbre = ^arbre ;type ptr_arbre = ^arbre ;
arbre = recordarbre = record
champ : ptr_arbrechamp : ptr_arbre
end ;end ;
10 octobre 2007 Cours de compilation 6 - Intranet 13
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----• Les types récursifs en Pascal :Les types récursifs en Pascal :
type ptr_arbre = type ptr_arbre = ^arbre^arbre ; ;
arbrearbre = record = record
champ : ptr_arbrechamp : ptr_arbre
end ;end ;
Une référenceUne référenceen avant (la seuleen avant (la seuletolérée en Pascal).tolérée en Pascal).
10 octobre 2007 Cours de compilation 6 - Intranet 14
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----• Les types récursifs en Pascal :Les types récursifs en Pascal :
type ptr_arbre = type ptr_arbre = ^arbre^arbre ; ;
arbrearbre = record = record
champ : ptr_arbrechamp : ptr_arbre
end ;end ;
• Les types récursifs en C :Les types récursifs en C :
struct moi_memestruct moi_meme
{{
struct moi_meme *self ; struct moi_meme *self ;
}}
*ptr_structure ;*ptr_structure ;
Une référenceUne référenceen avant (la seuleen avant (la seuletolérée en Pascal).tolérée en Pascal).
10 octobre 2007 Cours de compilation 6 - Intranet 15
L’analyse sémantiqueL’analyse sémantique----------------------------------------------------------------------------------------------------------------------------
----• Les types récursifs en Pascal :Les types récursifs en Pascal :
type ptr_arbre = type ptr_arbre = ^arbre^arbre ; ;
arbrearbre = record = record
champ : ptr_arbrechamp : ptr_arbre
end ;end ;
• Les types récursifs en C :Les types récursifs en C :
struct struct moi_mememoi_meme
{{
struct struct moi_mememoi_meme *self ; *self ;
}}
*ptr_structure ;*ptr_structure ;
Une référenceUne référenceen avant (la seuleen avant (la seuletolérée en Pascal).tolérée en Pascal).
Nous introduisonsNous introduisonsun nom auxiliaire !un nom auxiliaire !
10 octobre 2007 Cours de compilation 6 - Intranet 16
Vérification des typesVérification des types----------------------------------------------------------------------------------------------------------------------------
----• Il s’agit de vérifier l’adéquation entre :Il s’agit de vérifier l’adéquation entre :
– Les opérateurs et leurs arguments :Les opérateurs et leurs arguments :
#define ab 5 . . . int x . . . x + ( 3 * ab ) #define ab 5 . . . int x . . . x + ( 3 * ab )
10 octobre 2007 Cours de compilation 6 - Intranet 17
Vérification des typesVérification des types----------------------------------------------------------------------------------------------------------------------------
----• Il s’agit de vérifier l’adéquation entre :Il s’agit de vérifier l’adéquation entre :
– Les opérateurs et leurs arguments :Les opérateurs et leurs arguments :
#define ab 5 . . . int x . . . x + ( 3 * ab ) #define ab 5 . . . int x . . . x + ( 3 * ab )
– Les membres gauche et droits d’une affectation :Les membres gauche et droits d’une affectation :
float x ; . . . x = 3.14 ;float x ; . . . x = 3.14 ;
10 octobre 2007 Cours de compilation 6 - Intranet 18
Vérification des typesVérification des types----------------------------------------------------------------------------------------------------------------------------
----• Il s’agit de vérifier l’adéquation entre :Il s’agit de vérifier l’adéquation entre :
– Les opérateurs et leurs arguments :Les opérateurs et leurs arguments :
#define ab 5 . . . int x . . . x + ( 3 * ab ) #define ab 5 . . . int x . . . x + ( 3 * ab )
– Les membres gauche et droits d’une affectation :Les membres gauche et droits d’une affectation :
float x ; . . . x = 3.14 ;float x ; . . . x = 3.14 ;
– Les déclarations et appels des procédures et Les déclarations et appels des procédures et fonctions :fonctions :
float f ( int x , float y ) ;float f ( int x , float y ) ;
. . . f ( 5 , 3.14 ) . . .. . . f ( 5 , 3.14 ) . . .
10 octobre 2007 Cours de compilation 6 - Intranet 19
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
10 octobre 2007 Cours de compilation 6 - Intranet 20
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
10 octobre 2007 Cours de compilation 6 - Intranet 21
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
++
11
**
10 octobre 2007 Cours de compilation 6 - Intranet 22
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
++
11
**
int*int*
10 octobre 2007 Cours de compilation 6 - Intranet 23
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
++
11
**
int*int*
intint
10 octobre 2007 Cours de compilation 6 - Intranet 24
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
++
11
**
int*int*
intint intint
10 octobre 2007 Cours de compilation 6 - Intranet 25
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
+_int+_int
11
**
int*int*
intint intint
intint
10 octobre 2007 Cours de compilation 6 - Intranet 26
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
+_int+_int
11
**
int*int*
intint intint
intint floatfloat
10 octobre 2007 Cours de compilation 6 - Intranet 27
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
+_int+_int
11
*_float*_float
int*int*
intint intint
intint floatfloat
floatfloat
10 octobre 2007 Cours de compilation 6 - Intranet 28
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous faisons de la synthèse de types !Nous faisons de la synthèse de types !
– Nous partons des feuilles (variables et constantes) Nous partons des feuilles (variables et constantes) dont les types sont connus !dont les types sont connus !
– Nous déduisons et vérifions les types des Nous déduisons et vérifions les types des expressions plus complexes !expressions plus complexes !
int *p;int *p;
float q;float q;
pp
derefderef
+_int+_int
11
int_2_floatint_2_float
int*int*
intint intint
intint floatfloat
Au passage,Au passage,nous explicitonsnous explicitonsla conversionla conversionentre types !entre types !
*_float*_float floatfloat
10 octobre 2007 Cours de compilation 6 - Intranet 29
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
10 octobre 2007 Cours de compilation 6 - Intranet 30
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
#define ab 2#define ab 2
int x;int x;
22
++
11
xx
**
10 octobre 2007 Cours de compilation 6 - Intranet 31
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
#define ab 2#define ab 2
int x;int x;
22
++
11
xx
**
intint intint
intint intint
intint
10 octobre 2007 Cours de compilation 6 - Intranet 32
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
#define ab 2#define ab 2
int x;int x;
22
++
11
xx
**
val = 2 &val = 2 & int int intint
intint intint
intint
10 octobre 2007 Cours de compilation 6 - Intranet 33
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
#define ab 2#define ab 2
int x;int x;
22
++
11
xx
**
val = 2 &val = 2 & int int int int & val = 1& val = 1
intint intint
intint
10 octobre 2007 Cours de compilation 6 - Intranet 34
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
#define ab 2#define ab 2
int x;int x;
22
++
11
xx
**
val = 2 &val = 2 & int int int int & val = 1& val = 1
val = 3 &val = 3 & int int intint
intint
10 octobre 2007 Cours de compilation 6 - Intranet 35
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
#define ab 2#define ab 2
int x;int x;
22
++
11
xx
**
val = 2 &val = 2 & int int int int & val = 1& val = 1
val = 3 &val = 3 & int int int int & val = ?& val = ?
intint
10 octobre 2007 Cours de compilation 6 - Intranet 36
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• Nous pouvons même propager des constantes, Nous pouvons même propager des constantes,
introduites par exemple à l’aide de #define !introduites par exemple à l’aide de #define !
#define ab 2#define ab 2
int x;int x;
22
++
11
xx
**
val = 2 &val = 2 & int int int int & val = 1& val = 1
val = 3 &val = 3 & int int int int & val = ?& val = ?
int int & val = ?& val = ?
10 octobre 2007 Cours de compilation 6 - Intranet 37
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• On vérifie égalementOn vérifie également
– que les tests des if , while , . . . sont des que les tests des if , while , . . . sont des booléens, sauf en C !booléens, sauf en C !
10 octobre 2007 Cours de compilation 6 - Intranet 38
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• On vérifie égalementOn vérifie également
– que les tests des if , while , . . . sont des que les tests des if , while , . . . sont des booléens, sauf en C !booléens, sauf en C !
– que les tableaux ne débordent pas, sauf en C !que les tableaux ne débordent pas, sauf en C !
10 octobre 2007 Cours de compilation 6 - Intranet 39
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• On vérifie égalementOn vérifie également
– que les tests des if , while , . . . sont des que les tests des if , while , . . . sont des booléens, sauf en C !booléens, sauf en C !
– que les tableaux ne débordent pas, sauf en C !que les tableaux ne débordent pas, sauf en C !
var A = array [ 17 . . 39 ] of . . .var A = array [ 17 . . 39 ] of . . .
10 octobre 2007 Cours de compilation 6 - Intranet 40
Principe de la vérification des typesPrincipe de la vérification des types----------------------------------------------------------------------------------------------------------------------------
----• On vérifie égalementOn vérifie également
– que les tests des if , while , . . . sont des que les tests des if , while , . . . sont des booléens, sauf en C !booléens, sauf en C !
– que les tableaux ne débordent pas, sauf en C !que les tableaux ne débordent pas, sauf en C !
var A = array [ 17 . . 39 ] of . . .var A = array [ 17 . . 39 ] of . . .
A [ i ]A [ i ] devientdevient
testtest
i >= 17i >= 17 ERREURERREURtesttest
i <= 39i <= 39 ERREURERREURA [ i ]A [ i ]
10 octobre 2007 Cours de compilation 6 - Intranet 41
V I S I B I L I T E V I S I B I L I T E L E X I C A L EL E X I C A L E
E TE T
T A B L E ST A B L E SD E SD E S
S Y M B O L E SS Y M B O L E S
10 octobre 2007 Cours de compilation 6 - Intranet 42
La table des symbolesLa table des symboles----------------------------------------------------------------------------------------------------------------------------
----• Concernant les variablesConcernant les variables
– nous construisons la « table des symboles »,nous construisons la « table des symboles »,– nous respectons la « visibilité lexicale »,nous respectons la « visibilité lexicale »,– nous déduisons la « durée de vie » des variables !nous déduisons la « durée de vie » des variables !
10 octobre 2007 Cours de compilation 6 - Intranet 43
La table des symbolesLa table des symboles----------------------------------------------------------------------------------------------------------------------------
----• Concernant les variablesConcernant les variables
– nous construisons la « table des symboles »,nous construisons la « table des symboles »,– nous respectons la « visibilité lexicale »,nous respectons la « visibilité lexicale »,– nous déduisons la « durée de vie » des variables !nous déduisons la « durée de vie » des variables !
• La table des symboles collecte pour chaque variableLa table des symboles collecte pour chaque variable
– son type, ses éventuels paramètres, des son type, ses éventuels paramètres, des attributs, . . .attributs, . . .
– prend garde aux homonymes avec des numéros prend garde aux homonymes avec des numéros uniques.uniques.
10 octobre 2007 Cours de compilation 6 - Intranet 44
La table des symbolesLa table des symboles----------------------------------------------------------------------------------------------------------------------------
----• Concernant les variablesConcernant les variables
– nous construisons la « table des symboles »,nous construisons la « table des symboles »,– nous respectons la « visibilité lexicale »,nous respectons la « visibilité lexicale »,– nous déduisons la « durée de vie » des variables !nous déduisons la « durée de vie » des variables !
• La table des symboles collecte pour chaque variableLa table des symboles collecte pour chaque variable
– son type, ses éventuels paramètres, des son type, ses éventuels paramètres, des attributs, . . .attributs, . . .
– prend garde aux homonymes avec des numéros prend garde aux homonymes avec des numéros uniques.uniques.11
22
33
......
xx
ff
xx
......
intint
int->intint->int
floatfloat
......
//
inlineinline
doubledouble
......
10 octobre 2007 Cours de compilation 6 - Intranet 45
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
10 octobre 2007 Cours de compilation 6 - Intranet 46
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( float z )int f ( float z )
{ int x ;{ int x ;
int t ;int t ;
. . . x . . . y . . . z . . . t . . .. . . x . . . y . . . z . . . t . . .
}}
10 octobre 2007 Cours de compilation 6 - Intranet 47
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( float z )int f ( float z )
{ { int x ;int x ;
int t ;int t ;
. . . . . . xx . . . y . . . z . . . t . . . . . . y . . . z . . . t . . .
}}
10 octobre 2007 Cours de compilation 6 - Intranet 48
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( float z )int f ( float z )
{ { int x ;int x ;
int t ;int t ;
. . . . . . xx . . . y . . . z . . . t . . . . . . y . . . z . . . t . . .
}}
Cette occurrence de x est masquéeCette occurrence de x est masquéepar la redéfinition locale !par la redéfinition locale !
10 octobre 2007 Cours de compilation 6 - Intranet 49
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( float z )int f ( float z )
{ { int x ;int x ;
int t ;int t ;
. . . . . . xx . . . . . . yy . . . z . . . t . . . . . . z . . . t . . .
}}
Cette occurrence de x est masquéeCette occurrence de x est masquéepar la redéfinition locale !par la redéfinition locale !
10 octobre 2007 Cours de compilation 6 - Intranet 50
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( float z )int f ( float z )
{ { int x ;int x ;
int t ;int t ;
. . . . . . xx . . . . . . yy . . . z . . . t . . . . . . z . . . t . . .
}}
Cette occurrence de x est masquéeCette occurrence de x est masquéepar la redéfinition locale !par la redéfinition locale !
La variable y est dite « libre » dans f !La variable y est dite « libre » dans f !(variable globale)(variable globale)
10 octobre 2007 Cours de compilation 6 - Intranet 51
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( int f ( float zfloat z ) )
{ { int x ;int x ;
int t ;int t ;
. . . . . . xx . . . . . . yy . . . . . . zz . . . t . . . . . . t . . .
}}
Cette occurrence de x est masquéeCette occurrence de x est masquéepar la redéfinition locale !par la redéfinition locale !
La variable y est dite « libre » dans f !La variable y est dite « libre » dans f !(variable globale)(variable globale)
10 octobre 2007 Cours de compilation 6 - Intranet 52
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( int f ( float zfloat z ) )
{ { int x ;int x ;
int t ;int t ;
. . . . . . xx . . . . . . yy . . . . . . zz . . . . . . tt . . . . . .
}}
Cette occurrence de x est masquéeCette occurrence de x est masquéepar la redéfinition locale !par la redéfinition locale !
La variable y est dite « libre » dans f !La variable y est dite « libre » dans f !(variable globale)(variable globale)
10 octobre 2007 Cours de compilation 6 - Intranet 53
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Qui référence quoi ?Qui référence quoi ?
int x ;int x ;
int y ;int y ;
int f ( int f ( float zfloat z ) )
{ { int x ;int x ;
int t ;int t ;
. . . . . . xx . . . . . . yy . . . . . . zz . . . . . . tt . . . . . .
}}
Cette occurrence de x est masquéeCette occurrence de x est masquéepar la redéfinition locale !par la redéfinition locale !
x , t et z sont des variablesx , t et z sont des variablesdites « liées » dans f !dites « liées » dans f !
(variables locales)(variables locales)
La variable y est dite « libre » dans f !La variable y est dite « libre » dans f !(variable globale)(variable globale)
10 octobre 2007 Cours de compilation 6 - Intranet 54
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Un bloc !Un bloc !
10 octobre 2007 Cours de compilation 6 - Intranet 55
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Un bloc !Un bloc !
{ { Les variables localesLes variables locales
. . .. . .
. . .. . .
. . .. . .
. . .. . .
}}
10 octobre 2007 Cours de compilation 6 - Intranet 56
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Un bloc !Un bloc !
{ { Les variables locales Les variables locales sont crééessont créées
. . .. . .
. . .. . .
. . .. . .
. . .. . .
}}
EntréeEntrée
10 octobre 2007 Cours de compilation 6 - Intranet 57
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Un bloc !Un bloc !
{ { Les variables locales Les variables locales sont crééessont créées
. . .. . .
. . .. . .
. . .. . .
. . .. . .
}}
EntréeEntrée
ExécutionExécution
10 octobre 2007 Cours de compilation 6 - Intranet 58
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Un bloc !Un bloc !
{ { Les variables locales Les variables locales sont crééessont créées
. . .. . .
. . .. . .
. . .. . .
. . .. . .
} } Les variables locales sont détruitesLes variables locales sont détruites
EntréeEntrée
ExécutionExécution
SortieSortie
10 octobre 2007 Cours de compilation 6 - Intranet 59
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Un bloc !Un bloc !
{ { Les variables locales Les variables locales sont crééessont créées
. . .. . .
. . .. . .
. . .. . .
. . .. . .
} } Les variables locales sont détruitesLes variables locales sont détruites
La durée de vie est « statique » ou La durée de vie est « statique » ou « lexicale » ! ! !« lexicale » ! ! !
EntréeEntrée
ExécutionExécution
SortieSortie
10 octobre 2007 Cours de compilation 6 - Intranet 60
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
10 octobre 2007 Cours de compilation 6 - Intranet 61
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
Blocs disjoints Blocs disjoints
10 octobre 2007 Cours de compilation 6 - Intranet 62
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
Blocs disjoints Blocs Blocs disjoints Blocs englobantsenglobants
10 octobre 2007 Cours de compilation 6 - Intranet 63
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
{ . . . } { . . . } { { . . . } { . . . } { . . . } { { . . . } }}
Blocs disjoints Blocs englobantsBlocs disjoints Blocs englobants
10 octobre 2007 Cours de compilation 6 - Intranet 64
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
Visibilité ! ! !Visibilité ! ! !
Blocs disjoints Blocs Blocs disjoints Blocs englobantsenglobants
10 octobre 2007 Cours de compilation 6 - Intranet 65
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
Visibilité ! ! !Visibilité ! ! !
Blocs disjoints Blocs Blocs disjoints Blocs englobantsenglobants
ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 66
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
Visibilité ! ! !Visibilité ! ! !
Blocs disjoints Blocs Blocs disjoints Blocs englobantsenglobants
ICIICI
ouioui
nonnon
10 octobre 2007 Cours de compilation 6 - Intranet 67
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
Visibilité ! ! !Visibilité ! ! !
Blocs disjoints Blocs Blocs disjoints Blocs englobantsenglobants
ICIICI
ouioui
nonnon
ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 68
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Organisation relative des blocs !Organisation relative des blocs !
Visibilité ! ! !Visibilité ! ! !
Blocs disjoints Blocs Blocs disjoints Blocs englobantsenglobants
ICIICI
ouioui
nonnon
ICIICI
ouioui
ouioui
10 octobre 2007 Cours de compilation 6 - Intranet 69
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
10 octobre 2007 Cours de compilation 6 - Intranet 70
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
10 octobre 2007 Cours de compilation 6 - Intranet 71
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
10 octobre 2007 Cours de compilation 6 - Intranet 72
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
10 octobre 2007 Cours de compilation 6 - Intranet 73
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 74
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
ICIICI
ouioui
ouioui
ouioui
10 octobre 2007 Cours de compilation 6 - Intranet 75
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
ICIICI
ouioui
ouioui
ouioui
10 octobre 2007 Cours de compilation 6 - Intranet 76
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
ICIICI
ouioui
ouioui
ouioui
nonnonnonnon
nonnon
10 octobre 2007 Cours de compilation 6 - Intranet 77
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
10 octobre 2007 Cours de compilation 6 - Intranet 78
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Table desTable dessymbolessymboleschaînée :chaînée :
float yfloat y
int xint x
//
int xint x
float zfloat z
10 octobre 2007 Cours de compilation 6 - Intranet 79
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Règles de visibilité :Règles de visibilité :
- Nous voyons tout ce qui nous englobe (visibilité lexicale) - Nous voyons tout ce qui nous englobe (visibilité lexicale) !!
- Pour les homonymes, nous voyons l’occurrence la plus - Pour les homonymes, nous voyons l’occurrence la plus interne !interne !
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Table desTable dessymbolessymboleschaînée :chaînée :
float yfloat y
int xint x
//
int xint x
float zfloat z
L’occurrence externeL’occurrence externede x est masquée ! !de x est masquée ! !
10 octobre 2007 Cours de compilation 6 - Intranet 80
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
10 octobre 2007 Cours de compilation 6 - Intranet 81
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
10 octobre 2007 Cours de compilation 6 - Intranet 82
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
10 octobre 2007 Cours de compilation 6 - Intranet 83
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
10 octobre 2007 Cours de compilation 6 - Intranet 84
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 85
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 86
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 87
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Toutes les variables ontToutes les variables ontpu être initialisées !pu être initialisées !
10 octobre 2007 Cours de compilation 6 - Intranet 88
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Toutes les variables ontToutes les variables ontpu être initialisées !pu être initialisées !
L’occurrence externeL’occurrence externede x est masquée ! !de x est masquée ! !
10 octobre 2007 Cours de compilation 6 - Intranet 89
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Toutes les variables ontToutes les variables ontpu être initialisées !pu être initialisées !
L’occurrence externeL’occurrence externede x est masquée ! !de x est masquée ! !
10 octobre 2007 Cours de compilation 6 - Intranet 90
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Toutes les variables ontToutes les variables ontpu être initialisées !pu être initialisées !
L’occurrence externeL’occurrence externede x est masquée ! !de x est masquée ! !
ENTREEENTREE
10 octobre 2007 Cours de compilation 6 - Intranet 91
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Toutes les variables ontToutes les variables ontpu être initialisées !pu être initialisées !
L’occurrence externeL’occurrence externede x est masquée ! !de x est masquée ! !
ENTREEENTREE
SORTIESORTIE
10 octobre 2007 Cours de compilation 6 - Intranet 92
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution :Discipline d’exécution :
- Nous entrons dans les blocs en respectant les niveaux !- Nous entrons dans les blocs en respectant les niveaux !
- Nous exécutons les blocs en commençant au début !- Nous exécutons les blocs en commençant au début !
ICIICI
int x ;int x ;
int x ; float y ;int x ; float y ;
float z ;float z ;
Toutes les variables ontToutes les variables ontpu être initialisées !pu être initialisées !
L’occurrence externeL’occurrence externede x est masquée ! !de x est masquée ! !
ENTREEENTREE
SORTIESORTIE
10 octobre 2007 Cours de compilation 6 - Intranet 93
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution des GOTO :Discipline d’exécution des GOTO :
10 octobre 2007 Cours de compilation 6 - Intranet 94
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution des GOTO :Discipline d’exécution des GOTO :
- Un GOTO est un saut vers une instruction (cf. - Un GOTO est un saut vers une instruction (cf. assembleur) !assembleur) !
10 octobre 2007 Cours de compilation 6 - Intranet 95
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution des GOTO :Discipline d’exécution des GOTO :
- Un GOTO est un saut vers une instruction (cf. - Un GOTO est un saut vers une instruction (cf. assembleur) !assembleur) !
- Les GOTO ne peuvent pas être quelconques !- Les GOTO ne peuvent pas être quelconques !
10 octobre 2007 Cours de compilation 6 - Intranet 96
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution des GOTO :Discipline d’exécution des GOTO :
- Un GOTO est un saut vers une instruction (cf. - Un GOTO est un saut vers une instruction (cf. assembleur) !assembleur) !
- Les GOTO ne peuvent pas être quelconques !- Les GOTO ne peuvent pas être quelconques !
10 octobre 2007 Cours de compilation 6 - Intranet 97
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution des GOTO :Discipline d’exécution des GOTO :
- Un GOTO est un saut vers une instruction (cf. - Un GOTO est un saut vers une instruction (cf. assembleur) !assembleur) !
- Les GOTO ne peuvent pas être quelconques !- Les GOTO ne peuvent pas être quelconques !
GOTOGOTO
Les variables ne sont pas initialisées !Les variables ne sont pas initialisées !
ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 98
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Discipline d’exécution des GOTO :Discipline d’exécution des GOTO :
- Un GOTO est un saut vers une instruction (cf. - Un GOTO est un saut vers une instruction (cf. assembleur) !assembleur) !
- Les GOTO ne peuvent pas être quelconques !- Les GOTO ne peuvent pas être quelconques !
GOTOGOTO
Les variables ne sont pas initialisées !Les variables ne sont pas initialisées !
ICIICI
GOTOGOTO
10 octobre 2007 Cours de compilation 6 - Intranet 99
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Conséquences :Conséquences :
10 octobre 2007 Cours de compilation 6 - Intranet 100
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Conséquences :Conséquences :
Le dernier bloc dans lequel nous sommes Le dernier bloc dans lequel nous sommes entrésentrés
sera le premier que nous allons quitter !sera le premier que nous allons quitter !
10 octobre 2007 Cours de compilation 6 - Intranet 101
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Conséquences :Conséquences :
Le dernier bloc dans lequel nous sommes Le dernier bloc dans lequel nous sommes entrésentrés
sera le premier que nous allons quitter !sera le premier que nous allons quitter !
Tout ce qui est lexicalement visible depuis unTout ce qui est lexicalement visible depuis un
endroit a pu être initialisé au paravent !endroit a pu être initialisé au paravent !
10 octobre 2007 Cours de compilation 6 - Intranet 102
La visibilité lexicaleLa visibilité lexicale----------------------------------------------------------------------------------------------------------------------------
---- Conséquences :Conséquences :
Le dernier bloc dans lequel nous sommes Le dernier bloc dans lequel nous sommes entrésentrés
sera le premier que nous allons quitter !sera le premier que nous allons quitter !
Tout ce qui est lexicalement visible depuis unTout ce qui est lexicalement visible depuis un
endroit a pu être initialisé au paravent !endroit a pu être initialisé au paravent !
10 octobre 2007 Cours de compilation 6 - Intranet 103
L AL A
V I S I B I L I T EV I S I B I L I T E
D Y N A M I Q U ED Y N A M I Q U E
10 octobre 2007 Cours de compilation 6 - Intranet 104
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont Toutes les variables de la pile sont
visibles (en fait leurs dernières visibles (en fait leurs dernières occurrences) ! ! !occurrences) ! ! !
10 octobre 2007 Cours de compilation 6 - Intranet 105
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
10 octobre 2007 Cours de compilation 6 - Intranet 106
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
En visibilité lexicale,En visibilité lexicale,quand nous sommes dansquand nous sommes dansg , nous ne voyons pas leg , nous ne voyons pas le
paramètre formel x de f !paramètre formel x de f !
10 octobre 2007 Cours de compilation 6 - Intranet 107
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
PILEPILE
10 octobre 2007 Cours de compilation 6 - Intranet 108
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
PILEPILEL’appel initialL’appel initialest f ( 5 ) ! ! !est f ( 5 ) ! ! !
10 octobre 2007 Cours de compilation 6 - Intranet 109
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
PILEPILEL’appel initialL’appel initialest f ( 5 ) ! ! !est f ( 5 ) ! ! !
f ( 5 )f ( 5 )
x = 5x = 5
y = 3y = 3
10 octobre 2007 Cours de compilation 6 - Intranet 110
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
PILEPILEL’appel initialL’appel initialest f ( 5 ) ! ! !est f ( 5 ) ! ! !
f ( 5 )f ( 5 )
x = 5x = 5
y = 3y = 3
10 octobre 2007 Cours de compilation 6 - Intranet 111
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
PILEPILEL’appel initialL’appel initialest g ( 4 ) ! ! !est g ( 4 ) ! ! !
10 octobre 2007 Cours de compilation 6 - Intranet 112
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
PILEPILEL’appel initialL’appel initialest g ( 4 ) ! ! !est g ( 4 ) ! ! !
y = 4y = 4g ( 4 )g ( 4 )
10 octobre 2007 Cours de compilation 6 - Intranet 113
La visibilité dynamiqueLa visibilité dynamique----------------------------------------------------------------------------------------------------------------------------
----Toutes les variables de la pile sont visibles Toutes les variables de la pile sont visibles
(en fait leurs dernières occurrences) ! ! !(en fait leurs dernières occurrences) ! ! !
void f ( x )void f ( x )
{{
g ( 3 ) ;g ( 3 ) ;
}}
void g ( y )void g ( y )
{{
......
} } ICIICI
PILEPILEL’appel initialL’appel initialest g ( 4 ) ! ! !est g ( 4 ) ! ! !
y = 4y = 4g ( 4 )g ( 4 )
10 octobre 2007 Cours de compilation 6 - Intranet 114
L E SL E S
D U R E E SD U R E E S
D ED E
V I EV I E
10 octobre 2007 Cours de compilation 6 - Intranet 115
Les durées de vie des variablesLes durées de vie des variables----------------------------------------------------------------------------------------------------------------------------
----• Les variables déclarées ont une durée de vie Les variables déclarées ont une durée de vie
« statique » !« statique » !
– Elles sont créées à l’entrée dans le bloc !Elles sont créées à l’entrée dans le bloc !– Elles sont détruites à la sortie du bloc !Elles sont détruites à la sortie du bloc !
10 octobre 2007 Cours de compilation 6 - Intranet 116
Les durées de vie des variablesLes durées de vie des variables----------------------------------------------------------------------------------------------------------------------------
----• Les variables déclarées ont une durée de vie Les variables déclarées ont une durée de vie
« statique » !« statique » !
– Elles sont créées à l’entrée dans le bloc !Elles sont créées à l’entrée dans le bloc !– Elles sont détruites à la sortie du bloc !Elles sont détruites à la sortie du bloc !
• Les valeurs allouées ont une durée de vie Les valeurs allouées ont une durée de vie « dynamique » !« dynamique » !
– Elles sont créées par malloc , . . . !Elles sont créées par malloc , . . . !– Elles sont détruites explicitement !Elles sont détruites explicitement !
10 octobre 2007 Cours de compilation 6 - Intranet 117
Les durées de vie des variablesLes durées de vie des variables----------------------------------------------------------------------------------------------------------------------------
----• Les variables déclarées ont une durée de vie Les variables déclarées ont une durée de vie
« statique » !« statique » !
– Elles sont créées à l’entrée dans le bloc !Elles sont créées à l’entrée dans le bloc !– Elles sont détruites à la sortie du bloc !Elles sont détruites à la sortie du bloc !
• Les valeurs allouées ont une durée de vie Les valeurs allouées ont une durée de vie « dynamique » !« dynamique » !
– Elles sont créées par malloc , . . . !Elles sont créées par malloc , . . . !– Elles sont détruites explicitement !Elles sont détruites explicitement !
10 octobre 2007 Cours de compilation 6 - Intranet 118
Les durées de vie des variablesLes durées de vie des variables----------------------------------------------------------------------------------------------------------------------------
----• Les variables déclarées ont une durée de vie Les variables déclarées ont une durée de vie
« statique » !« statique » !
– Elles sont créées à l’entrée dans le bloc !Elles sont créées à l’entrée dans le bloc !– Elles sont détruites à la sortie du bloc !Elles sont détruites à la sortie du bloc !
• Les valeurs allouées ont une durée de vie « dynamique » !Les valeurs allouées ont une durée de vie « dynamique » !
– Elles sont créées par malloc , . . . !Elles sont créées par malloc , . . . !– Elles sont détruites explicitement !Elles sont détruites explicitement !
• Attention : Attention : { . . . *p ;{ . . . *p ;
p = malloc ( . . . ) ;p = malloc ( . . . ) ;
} } p sera détruite, mais pas la donnée allouée !p sera détruite, mais pas la donnée allouée !
10 octobre 2007 Cours de compilation 6 - Intranet 119
E N V I R O N N E M E N TE N V I R O N N E M E N T
D ‘ E X E C U T I O ND ‘ E X E C U T I O N
10 octobre 2007 Cours de compilation 6 - Intranet 120
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----
10 octobre 2007 Cours de compilation 6 - Intranet 121
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----
• Dans la pile nous gérons :Dans la pile nous gérons :
– Les imbrications des opérations (adresses de Les imbrications des opérations (adresses de retour) !retour) !
10 octobre 2007 Cours de compilation 6 - Intranet 122
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----
• Dans la pile nous gérons :Dans la pile nous gérons :
– Les imbrications des opérations (adresses de Les imbrications des opérations (adresses de retour) !retour) !
– Les variables du programme !Les variables du programme !
10 octobre 2007 Cours de compilation 6 - Intranet 123
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----
• Dans la pile nous gérons :Dans la pile nous gérons :
– Les imbrications des opérations (adresses de Les imbrications des opérations (adresses de retour) !retour) !
– Les variables du programme !Les variables du programme !
– Les variables temporaires du compilateur !Les variables temporaires du compilateur !
10 octobre 2007 Cours de compilation 6 - Intranet 124
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----
• Dans la pile nous gérons :Dans la pile nous gérons :
– Les imbrications des opérations (adresses de Les imbrications des opérations (adresses de retour) !retour) !
– Les variables du programme !Les variables du programme !
– Les variables temporaires du compilateur !Les variables temporaires du compilateur !
– Les paramètres des fonctions et procédures !Les paramètres des fonctions et procédures !
10 octobre 2007 Cours de compilation 6 - Intranet 125
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----• Pour les fonctions et procédures nous distinguons Pour les fonctions et procédures nous distinguons
entreentre
leurs déclarations et leurs activations !leurs déclarations et leurs activations !
10 octobre 2007 Cours de compilation 6 - Intranet 126
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----• Pour les fonctions et procédures nous distinguons Pour les fonctions et procédures nous distinguons
entreentre
leurs déclarations et leurs activations !leurs déclarations et leurs activations !
• SoientSoient proc f (... ) { ... f ... g ... }proc f (... ) { ... f ... g ... }
proc g (... ) { ... f ... g ... }proc g (... ) { ... f ... g ... }
10 octobre 2007 Cours de compilation 6 - Intranet 127
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----• Pour les fonctions et procédures nous distinguons Pour les fonctions et procédures nous distinguons
entreentre
leurs déclarations et leurs activations !leurs déclarations et leurs activations !
• SoientSoient proc f (... ) { ... f ... g ... }proc f (... ) { ... f ... g ... }
proc g (... ) { ... f ... g ... }proc g (... ) { ... f ... g ... }
• Un « arbre d’activations » possible :Un « arbre d’activations » possible :ff
gg
ff
gg
ff
gg
ff
10 octobre 2007 Cours de compilation 6 - Intranet 128
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----• Pour les fonctions et procédures nous distinguons Pour les fonctions et procédures nous distinguons
entreentre
leurs déclarations et leurs activations !leurs déclarations et leurs activations !
• SoientSoient proc f (... ) { ... f ... g ... }proc f (... ) { ... f ... g ... }
proc g (... ) { ... f ... g ... }proc g (... ) { ... f ... g ... }
• Un « arbre d’activations » possible :Un « arbre d’activations » possible :ff
gg
ff
gg
ff
gg
ff
Le parcours préfixe de l’arbreLe parcours préfixe de l’arbred’activation donne la séquenced’activation donne la séquence
des appels et retours de fonctions !des appels et retours de fonctions !
10 octobre 2007 Cours de compilation 6 - Intranet 129
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
10 octobre 2007 Cours de compilation 6 - Intranet 130
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
10 octobre 2007 Cours de compilation 6 - Intranet 131
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
10 octobre 2007 Cours de compilation 6 - Intranet 132
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
10 octobre 2007 Cours de compilation 6 - Intranet 133
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
mainmain
ff
ff
gg
hh
gg
10 octobre 2007 Cours de compilation 6 - Intranet 134
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
10 octobre 2007 Cours de compilation 6 - Intranet 135
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
mainmain
10 octobre 2007 Cours de compilation 6 - Intranet 136
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
mainmain
ff
ff
gg
hh
gg
10 octobre 2007 Cours de compilation 6 - Intranet 137
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
10 octobre 2007 Cours de compilation 6 - Intranet 138
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
Nous n’avons pas envieNous n’avons pas envied’inspecter toute la piled’inspecter toute la pileà chaque fois que nousà chaque fois que nousavons besoin de la valeuravons besoin de la valeurd’une variable !d’une variable !
10 octobre 2007 Cours de compilation 6 - Intranet 139
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUI, le bloc courant !OUI, le bloc courant !
10 octobre 2007 Cours de compilation 6 - Intranet 140
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NON, à cause de la lexicalité !NON, à cause de la lexicalité !
10 octobre 2007 Cours de compilation 6 - Intranet 141
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NON, pas la dernière activation !NON, pas la dernière activation !
10 octobre 2007 Cours de compilation 6 - Intranet 142
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NONNON
OUI, dernière activation d’un blocOUI, dernière activation d’un blocenglobant !englobant !
10 octobre 2007 Cours de compilation 6 - Intranet 143
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NONNON
OUIOUI
NON, c’est bien un bloc englobant,NON, c’est bien un bloc englobant,mais pas la dernière activation !mais pas la dernière activation !
10 octobre 2007 Cours de compilation 6 - Intranet 144
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NONNON
OUIOUI
NONNON
OUI, l’unique activation du blocOUI, l’unique activation du blocprincipal !principal !
10 octobre 2007 Cours de compilation 6 - Intranet 145
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NONNON
OUIOUI
NONNON
OUIOUI
En résumé :En résumé :
10 octobre 2007 Cours de compilation 6 - Intranet 146
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NONNON
OUIOUI
NONNON
OUIOUI
En résumé :En résumé :
Nous voyons lesNous voyons lesdernières activationsdernières activationsdu bloc courant etdu bloc courant etde ses blocsde ses blocsenglobants !englobants !
10 octobre 2007 Cours de compilation 6 - Intranet 147
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NONNON
OUIOUI
NONNON
OUIOUI
En résumé :En résumé :
Nous voyons lesNous voyons lesdernières activationsdernières activationsdu bloc courant etdu bloc courant etde ses blocsde ses blocsenglobants !englobants !
10 octobre 2007 Cours de compilation 6 - Intranet 148
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg OUIOUI
NONNON
NONNON
OUIOUI
NONNON
OUIOUI
En résumé :En résumé :
Nous voyons lesNous voyons lesdernières activationsdernières activationsdu bloc courant etdu bloc courant etde ses blocsde ses blocsenglobants !englobants !
Leur nombre dépendLeur nombre dépenddu texte dudu texte duprogramme !programme !
10 octobre 2007 Cours de compilation 6 - Intranet 149
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
L’adresseurL’adresseur
Nous créons une mini-pileNous créons une mini-pileappelée « adresseur »appelée « adresseur »ou « display » !ou « display » !
10 octobre 2007 Cours de compilation 6 - Intranet 150
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( … )f ( … )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
L’adresseurL’adresseur
L’adresseurL’adresseurrepère lesrepère lesblocs actifs.blocs actifs.
Nous créons une mini-pileNous créons une mini-pileappelée « adresseur »appelée « adresseur »ou « display » !ou « display » !
10 octobre 2007 Cours de compilation 6 - Intranet 151
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( f ( xx ) )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
L’adresseurL’adresseur
L’adresseurL’adresseurrepère lesrepère lesblocs actifs.blocs actifs.
xx
xx
Trouver leTrouver leparamètre xparamètre xde f . . .de f . . .
Nous créons une mini-pileNous créons une mini-pileappelée « adresseur »appelée « adresseur »ou « display » !ou « display » !
10 octobre 2007 Cours de compilation 6 - Intranet 152
L’environnement d’exécutionL’environnement d’exécution----------------------------------------------------------------------------------------------------------------------------
----main ()main ()var_mainvar_main
beginbeginendend
f ( f ( xx ) )var_fvar_f
beginbeginendend
g (…)g (…)var_gvar_gbeginbeginendend
h (…)h (…)var_hvar_hbeginbeginendend
La pileLa pile
mainmain
ff
ff
gg
hh
gg
L’adresseurL’adresseur
Nous créons une mini-pileNous créons une mini-pileappelée « adresseur »appelée « adresseur »ou « display » !ou « display » !
L’adresseurL’adresseurrepère lesrepère lesblocs actifs.blocs actifs.
xx
xx
Trouver leTrouver leparamètre xparamètre xde f de f est simple.est simple.
Niveau de fNiveau de f
10 octobre 2007 Cours de compilation 6 - Intranet 153
G E S T I O NG E S T I O N
D ED E
L ‘ A D R E S S E U RL ‘ A D R E S S E U R
10 octobre 2007 Cours de compilation 6 - Intranet 154
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle Soit f une fonction de niveau N qui appelle g !g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
10 octobre 2007 Cours de compilation 6 - Intranet 155
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle Soit f une fonction de niveau N qui appelle g !g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 1 ) g est de niveau N+1 :( 1 ) g est de niveau N+1 :
-- Nous rajoutons une entrée à Nous rajoutons une entrée à l’adresseur ! ! !l’adresseur ! ! !
10 octobre 2007 Cours de compilation 6 - Intranet 156
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle Soit f une fonction de niveau N qui appelle g !g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 1 ) g est de niveau N+1 :( 1 ) g est de niveau N+1 :
-- Nous rajoutons une entrée à Nous rajoutons une entrée à l’adresseur ! ! !l’adresseur ! ! !
11
NN
La pileLa pile
. . .. . .
10 octobre 2007 Cours de compilation 6 - Intranet 157
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle Soit f une fonction de niveau N qui appelle g !g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 1 ) g est de niveau N+1 :( 1 ) g est de niveau N+1 :
-- Nous rajoutons une entrée à Nous rajoutons une entrée à l’adresseur ! ! !l’adresseur ! ! !
11
NN
La pileLa pile
gg
. . .. . .
N+1N+1
10 octobre 2007 Cours de compilation 6 - Intranet 158
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle g !Soit f une fonction de niveau N qui appelle g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 2 ) g est de niveau N :( 2 ) g est de niveau N :
10 octobre 2007 Cours de compilation 6 - Intranet 159
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle g !Soit f une fonction de niveau N qui appelle g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 2 ) g est de niveau N :( 2 ) g est de niveau N :
-- Si g = f , la nouvelle activation invalide Si g = f , la nouvelle activation invalide l’ancienne !l’ancienne ! -- Si g <> f , alors f devient invisible par Si g <> f , alors f devient invisible par lexicalité !lexicalité !
10 octobre 2007 Cours de compilation 6 - Intranet 160
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle g !Soit f une fonction de niveau N qui appelle g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 2 ) g est de niveau N :( 2 ) g est de niveau N :
-- Si g = f , la nouvelle activation invalide Si g = f , la nouvelle activation invalide l’ancienne !l’ancienne ! -- Si g <> f , alors f devient invisible par Si g <> f , alors f devient invisible par lexicalité !lexicalité !
Dans tous les cas :Dans tous les cas :
-- Nous sauvons l’entrée N de l’adresseur ! Nous sauvons l’entrée N de l’adresseur ! -- Nous y installons le pointeur vers le bloc g ! Nous y installons le pointeur vers le bloc g ! -- A la sortie, nous restaurons l’entrée sauvée ! A la sortie, nous restaurons l’entrée sauvée !
10 octobre 2007 Cours de compilation 6 - Intranet 161
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle g !Soit f une fonction de niveau N qui appelle g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 3 ) g est de niveau N - k :( 3 ) g est de niveau N - k :
10 octobre 2007 Cours de compilation 6 - Intranet 162
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle g !Soit f une fonction de niveau N qui appelle g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 3 ) g est de niveau N - k :( 3 ) g est de niveau N - k :
Si k = 0 , nous retrouvons le cas 2 !Si k = 0 , nous retrouvons le cas 2 !
10 octobre 2007 Cours de compilation 6 - Intranet 163
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Soit f une fonction de niveau N qui appelle g !Soit f une fonction de niveau N qui appelle g !
•Discussion par cas suivant le niveau de g :Discussion par cas suivant le niveau de g :
( 3 ) g est de niveau N - k :( 3 ) g est de niveau N - k :
Si k = 0 , nous retrouvons le cas 2 !Si k = 0 , nous retrouvons le cas 2 !
Donc :Donc :
-- Nous sauvons les entrées N - k , . . . , N ! Nous sauvons les entrées N - k , . . . , N ! -- Nous y installons le pointeur vers le bloc g ! Nous y installons le pointeur vers le bloc g ! -- A la sortie, nous restaurons les entrées A la sortie, nous restaurons les entrées sauvées !sauvées !
10 octobre 2007 Cours de compilation 6 - Intranet 164
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Nous avons donc les quatre étapes suivantes :Nous avons donc les quatre étapes suivantes :
( 1 )( 1 )
11
N-k-1N-k-1
NN ff
10 octobre 2007 Cours de compilation 6 - Intranet 165
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Nous avons donc les quatre étapes suivantes :Nous avons donc les quatre étapes suivantes :
( 1 )( 1 )
11
N-k-1N-k-1
NN ff( 2 )( 2 )
11
N-k-1N-k-1
Sauvegardées ! ! !Sauvegardées ! ! !
10 octobre 2007 Cours de compilation 6 - Intranet 166
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Nous avons donc les quatre étapes suivantes :Nous avons donc les quatre étapes suivantes :
( 1 )( 1 )
11
N-k-1N-k-1
NN ff( 2 )( 2 )
11
N-k-1N-k-1
Sauvegardées ! ! !Sauvegardées ! ! !
( 3 )( 3 )
11
N-k-1N-k-1
N-kN-k gg
10 octobre 2007 Cours de compilation 6 - Intranet 167
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•Nous avons donc les quatre étapes suivantes :Nous avons donc les quatre étapes suivantes :
( 1 )( 1 )
11
N-k-1N-k-1
NN ff( 2 )( 2 )
11
N-k-1N-k-1
Sauvegardées ! ! !Sauvegardées ! ! !
( 3 )( 3 )
11
N-k-1N-k-1
N-kN-k gg ( 4 )( 4 )La restauration desLa restauration desentrées sauvegardéesentrées sauvegardéesnous ramène aunous ramène aupoint de départ.point de départ.
10 octobre 2007 Cours de compilation 6 - Intranet 168
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•En C nous avons :En C nous avons :
•Des variables globales de niveau 1 !Des variables globales de niveau 1 !•Des fonctions et procédures de niveau 2 !Des fonctions et procédures de niveau 2 !
10 octobre 2007 Cours de compilation 6 - Intranet 169
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•En C nous avons :En C nous avons :
•Des variables globales de niveau 1 !Des variables globales de niveau 1 !•Des fonctions et procédures de niveau 2 !Des fonctions et procédures de niveau 2 !
•Ce n’est pas la peine de gérer un adresseur de 2 Ce n’est pas la peine de gérer un adresseur de 2 niveaux !niveaux !
10 octobre 2007 Cours de compilation 6 - Intranet 170
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----•En C nous avons :En C nous avons :
•Des variables globales de niveau 1 !Des variables globales de niveau 1 !•Des fonctions et procédures de niveau 2 !Des fonctions et procédures de niveau 2 !
•Ce n’est pas la peine de gérer un adresseur de 2 Ce n’est pas la peine de gérer un adresseur de 2 niveaux !niveaux !
L’adresseurL’adresseur La pileLa pile
. . .. . .
10 octobre 2007 Cours de compilation 6 - Intranet 171
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----Le choix de C se justifie si nous voulons passer, de Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables manière simple, en argument des fonctions à variables libres !libres !
void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g ) ;h ( g ) ; }}
void h ( z )void h ( z ) {{ int x = 3 ;int x = 3 ; . . . z ( 4 ) . . . ;. . . z ( 4 ) . . . ; }}
10 octobre 2007 Cours de compilation 6 - Intranet 172
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----Le choix de C se justifie si nous voulons passer, de Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables manière simple, en argument des fonctions à variables libres !libres !
void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g ) ;h ( g ) ; }}
void h ( z )void h ( z ) {{ int x = 3 ;int x = 3 ; . . . z ( 4 ) . . . ;. . . z ( 4 ) . . . ; }}
Pour un appel f ( 5 ), laPour un appel f ( 5 ), lafonction g doit considérerfonction g doit considérer
que x vaut 5 !que x vaut 5 !
x = 5x = 5
10 octobre 2007 Cours de compilation 6 - Intranet 173
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----Le choix de C se justifie si nous voulons passer, de Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables manière simple, en argument des fonctions à variables libres !libres !
void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g )h ( g ) ; ; }}
void h ( void h ( zz ) ) {{ int x = 3 ;int x = 3 ; . . . z ( 4 ) . . . ;. . . z ( 4 ) . . . ; }}
Pour un appel f ( 5 ), laPour un appel f ( 5 ), lafonction g doit considérerfonction g doit considérer
que x vaut 5 !que x vaut 5 !
x = 5x = 5
La fonction g est passée àLa fonction g est passée àh où elle prend le nom z !h où elle prend le nom z !
10 octobre 2007 Cours de compilation 6 - Intranet 174
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----Le choix de C se justifie si nous voulons passer, de Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables manière simple, en argument des fonctions à variables libres !libres !
void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g )h ( g ) ; ; }}
void h ( void h ( zz ) ) {{ int x = 3int x = 3 ; ; . . . . . . z z ( 4 ) . . . ;( 4 ) . . . ; }}
Pour un appel f ( 5 ), laPour un appel f ( 5 ), lafonction g doit considérerfonction g doit considérer
que x vaut 5 !que x vaut 5 !
x = 5x = 5
La fonction g est passée àLa fonction g est passée àh où elle prend le nom z !h où elle prend le nom z !
z est appliquée dans un contexte où x vaut 3z est appliquée dans un contexte où x vaut 3alors qu’elle doit considérer que x vaut 5 !alors qu’elle doit considérer que x vaut 5 !
10 octobre 2007 Cours de compilation 6 - Intranet 175
La gestion de l’adresseurLa gestion de l’adresseur----------------------------------------------------------------------------------------------------------------------------
----Le choix de C se justifie si nous voulons passer, de Le choix de C se justifie si nous voulons passer, de manière simple, en argument des fonctions à variables manière simple, en argument des fonctions à variables libres !libres !
void f ( x )void f ( x ) {{ void g ( y ) return ( x+y ) ;void g ( y ) return ( x+y ) ; h ( g )h ( g ) ; ; }}
void h ( void h ( zz ) ) {{ int x = 3int x = 3 ; ; . . . . . . z z ( 4 ) . . . ;( 4 ) . . . ; }}
Pour un appel f ( 5 ), laPour un appel f ( 5 ), lafonction g doit considérerfonction g doit considérer
que x vaut 5 !que x vaut 5 !
x = 5x = 5
La fonction g est passée àLa fonction g est passée àh où elle prend le nom z !h où elle prend le nom z !
z est appliquée dans un contexte où x vaut 3z est appliquée dans un contexte où x vaut 3alors qu’elle doit considérer que x vaut 5 !alors qu’elle doit considérer que x vaut 5 !
Si les fonctions sont définies au mêmeSi les fonctions sont définies au mêmeniveau, le problème ne se pose pas carniveau, le problème ne se pose pas car
elles référencent toutes le même contexte !elles référencent toutes le même contexte !
10 octobre 2007 Cours de compilation 6 - Intranet 176
S T R U C T U R ES T R U C T U R E
D ‘ U ND ‘ U N
B L O CB L O C
D ‘ A C T I V A T I O ND ‘ A C T I V A T I O N
10 octobre 2007 Cours de compilation 6 - Intranet 177
La structure d’un bloc d’activationLa structure d’un bloc d’activation----------------------------------------------------------------------------------------------------------------------------
----
Lien de contrôleLien de contrôle
Point dePoint deréférence !référence !
Le blocLe blocprécédent !précédent !
10 octobre 2007 Cours de compilation 6 - Intranet 178
La structure d’un bloc d’activationLa structure d’un bloc d’activation----------------------------------------------------------------------------------------------------------------------------
----
Mémoire temporaireMémoire temporaire
Variables localesVariables locales
Sauvegarde des registresSauvegarde des registres
Les argumentsLes arguments
« Place pour le résultat » « Place pour le résultat »
Lien de contrôleLien de contrôle
Mis en placeMis en placepar l’appelé !par l’appelé !}}Mis en placeMis en placepar l’appelant !par l’appelant !}}
Point dePoint deréférence !référence !
Le blocLe blocprécédent !précédent !
10 octobre 2007 Cours de compilation 6 - Intranet 179
RésuméRésumé----------------------------------------------------------------------------------------------------------------------------
----
•Analyse sémantiqueAnalyse sémantique
•Environnement d’exécutionEnvironnement d’exécution
10 octobre 2007 Cours de compilation 6 - Intranet 180
C ’ e S t L a F i N ! C ’ e S t L a F i N ! ! !! !
b O n N eb O n N eJ o U r N é E ! ! !J o U r N é E ! ! !