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.

1. Les compilateurs... comment ça marche ?
Dinesh Bolkensteyn
@dbolkensteyn
14 janvier 2014

2. La face visible
public static <T> Collection<T>
identity(Collection<?> param) {
return param;
}

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. Ou moins visible...

5. Ou moins visible...

6. Architecture
Front End
●
●
Back End
Syntaxe
Sémantique
●
●
Optimisation
Génération de code

7. Front End
1. Lexer
2. Parser
3. Résolution des noms
4. Vérification des types

8. Front End : Lexer
foo + 42 * bar

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

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. Front End : Parser
foo + 42 * bar

12. Front End : Parser
foo + 42 * bar

13. Front End : Parser
foo + 42 * bar
Grammaire formelle
●
ADD :=
MUL {PLUS MUL}
MUL
●
MUL :=
PRIM {STAR PRIM}
PRIM
●
PRIM := ID | INTEGER

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. Front End : Résolution des noms
class Example {
public Example(
int foo) {
this.foo =
foo;
}
int foo;
}

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. 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. Front End : Vérifications des types
int a = 0 ; // OK
int a = 10 / 3 ; // OK
int a = 10.0 / 3 ; // KO

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. Back End
1. Optimisation
2. Génération de code

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. Merci !
Les compilateurs... comment ça marche ?
Dinesh Bolkensteyn
@dbolkensteyn