Les compilateurs... comment ça marche ?
Dinesh Bolkensteyn
@dbolkensteyn
14 janvier 2014
La face visible
public static <T> Collection<T>
identity(Collection<?> param) {
return param;
}
La face visible
public static <T> Collection<T>
identity(Collection<?> param) {
return param;
}
incompatible types
found

...
Ou moins visible...
Ou moins visible...
Architecture
Front End
●
●

Back End

Syntaxe

Sémantique

●
●

Optimisation

Génération de code
Front End
1. Lexer
2. Parser
3. Résolution des noms
4. Vérification des types
Front End : Lexer
foo + 42 * bar
Front End : Lexer
foo + 42 * bar

1. ID(« foo »)
2. PLUS(« + »)
3. INTEGER(« 42 »)
4. STAR(« * »)
5. ID(« bar »)
Front End : Lexer
foo + 42 * bar

Expressions régulières
●

●

1. ID(« foo »)
2. PLUS(« + »)
3. INTEGER(« 42 »)
4. STAR(« ...
Front End : Parser
foo + 42 * bar
Front End : Parser
foo + 42 * bar
Front End : Parser
foo + 42 * bar

Grammaire formelle
●

ADD :=
MUL {PLUS MUL}
MUL

●

MUL :=
PRIM {STAR PRIM}
PRIM

●

PR...
Front End : Parser
foo + 42 * bar

Fonctions récursives
add() {
Expr left = mul() ;
accept(PLUS) ;
Expr right = mul() ;
re...
Front End : Résolution des noms
class Example {
public Example(
int foo) {
this.foo =
foo;
}
int foo;
}
Front End : Résolution des noms
class Example {
public Example(

Phase 1:
Class(

int foo) {

fields => { foo }

this.foo ...
Front End : Résolution des noms
class Example {
public Example(

Résultat phase 1:
Class(
fields => { foo }

int foo) {

c...
Front End : Vérifications des types
int a = 0 ; // OK
int a = 10 / 3 ; // OK
int a = 10.0 / 3 ; // KO
Front End : Vérifications des types
int a = 0 ; // OK
int a = 10 / 3 ; // OK

Règles de type
●

int a = 10.0 / 3 ; // KO

...
Back End
1. Optimisation
2. Génération de code
Et ça va bien plus loin...
●

Inférence des types: val foo = ... ;

●

C++ template « meta-programming » :
template <int I...
Merci !

Les compilateurs... comment ça marche ?
Dinesh Bolkensteyn
@dbolkensteyn
Prochain SlideShare
Chargement dans…5
×

Un compilateur... comment ça marche?

376 vues

Publié le

Les compilateurs nous ennuient tous les jours avec des messages d'erreurs en chinois... alors qu'ils ne font que leur travail, et souvent le font à la perfection ;-)

(Re)découvrez comment les compilateurs fonctionnent en interne et ainsi à devenir plus indulgent à leur égard.

Publié dans : Technologie
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
376
Sur SlideShare
0
Issues des intégrations
0
Intégrations
25
Actions
Partages
0
Téléchargements
4
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Un compilateur... comment ça marche?

  1. 1. Les compilateurs... comment ça marche ? Dinesh Bolkensteyn @dbolkensteyn 14 janvier 2014
  2. 2. La face visible public static <T> Collection<T> identity(Collection<?> param) { return param; }
  3. 3. La face visible public static <T> Collection<T> identity(Collection<?> param) { return param; } incompatible types found : java.util.Collection<capture#42 of ?> required: java.util.Collection<T>
  4. 4. Ou moins visible...
  5. 5. Ou moins visible...
  6. 6. Architecture Front End ● ● Back End Syntaxe Sémantique ● ● Optimisation Génération de code
  7. 7. Front End 1. Lexer 2. Parser 3. Résolution des noms 4. Vérification des types
  8. 8. Front End : Lexer foo + 42 * bar
  9. 9. Front End : Lexer foo + 42 * bar 1. ID(« foo ») 2. PLUS(« + ») 3. INTEGER(« 42 ») 4. STAR(« * ») 5. ID(« bar »)
  10. 10. Front End : Lexer foo + 42 * bar Expressions régulières ● ● 1. ID(« foo ») 2. PLUS(« + ») 3. INTEGER(« 42 ») 4. STAR(« * ») 5. ID(« bar ») ID : [a-zA-Z][a-zA-Z0-9]*+ INTEGER : [0-9]++ ● PLUS : + ● STAR : * ● WHITESPACES : [ rn]++
  11. 11. Front End : Parser foo + 42 * bar
  12. 12. Front End : Parser foo + 42 * bar
  13. 13. Front End : Parser foo + 42 * bar Grammaire formelle ● ADD := MUL {PLUS MUL} MUL ● MUL := PRIM {STAR PRIM} PRIM ● PRIM := ID | INTEGER
  14. 14. Front End : Parser foo + 42 * bar Fonctions récursives add() { Expr left = mul() ; accept(PLUS) ; Expr right = mul() ; return new Add( left, right) }
  15. 15. Front End : Résolution des noms class Example { public Example( int foo) { this.foo = foo; } int foo; }
  16. 16. Front End : Résolution des noms class Example { public Example( Phase 1: Class( int foo) { fields => { foo } this.foo = constructors = { Constructor( foo; parameters = { foo } } ) int foo; } } )
  17. 17. Front End : Résolution des noms class Example { public Example( Résultat phase 1: Class( fields => { foo } int foo) { constructors = { this.foo = // field Constructor( foo; // parameter parameters = { foo } } ) int foo; } } )
  18. 18. Front End : Vérifications des types int a = 0 ; // OK int a = 10 / 3 ; // OK int a = 10.0 / 3 ; // KO
  19. 19. Front End : Vérifications des types int a = 0 ; // OK int a = 10 / 3 ; // OK Règles de type ● int a = 10.0 / 3 ; // KO e1 : int, e2 : int -> e1 + e2 : int ● e1 : double, e2 : int -> e1 + e2 : double ● etc.
  20. 20. Back End 1. Optimisation 2. Génération de code
  21. 21. Et ça va bien plus loin... ● Inférence des types: val foo = ... ; ● C++ template « meta-programming » : template <int I> int recursive(void) { return recursive<I - 1>(); }
  22. 22. Merci ! Les compilateurs... comment ça marche ? Dinesh Bolkensteyn @dbolkensteyn

×