% Introduction à `make`
% Inspirés des slides de F. Glück
% 9 octobre 2019

# Introduction

## A quoi ça sert?

- Automatiser le processus de conversion d'un type de fichier à un autre, en *gérant les dépendances*.
- Effectue la conversion des fichiers qui ont changé uniquement.
- Utilisé pour la compilation:
  - Création du code objet à partir des sources.
  - Création de l'exécutable à partir du code objet.
- Tout "gros" projet utilise `make` (pas uniquement en `C`).

# Utilisation de `make`

Le programme `make` exécutera la série d'instruction se trouvant dans un `Makefile` (ou `makefile` ou `GNUmakefile`).

## Le `Makefile`

- Contient une liste de *règles* et *dépendances*.
- Règles et dépendances construisent des *cibles*.
- Ici utilisé pour compiler une série de fichiers sources

    ```
    $ gcc -c example.c # + plein d'options..
    $ gcc -o example exemple.o # + plein d'options
    ```

:::::::::::::: {.columns}

::: {.column width="55%"}

## `Makefile`

```bash
example: example.o
    gcc -o example example.o

exmaple.o: exmaple.c example.h
    gcc -c example.c
```
:::
::: {.column width="45%"}

## Terminal

```bash
$ make
gcc -c example.c
gcc -o example example.o
```
:::
::::::::::::::

# Syntaxe d'un `Makefile` (1/4)

![Un exemple simple de `Makefile`.](figs/ex_makefile.svg){width=100%}

# Syntaxe d'un `Makefile` (2/4)

![La cible.](figs/ex_makefile_cible.svg){width=100%}

# Syntaxe d'un `Makefile` (3/4)

![Les dépendances.](figs/ex_makefile_dep.svg){width=100%}

# Syntaxe d'un `Makefile` (4/4)

![La règle.](figs/ex_makefile_regle.svg){width=100%}

# Principe de fonctionnement

1. `make` cherche le fichier `Makefile`, `makefile` ou `GNUmakefile` dans le répertoire courant.
2. Par défaut exécute la première cible, ou celle donnée en argument.
3. Décide si une cible doit être régénérée en comparant la date de modification (on recompile que ce qui a été modifié).
4. Regarde si les dépendances doivent être régénérées:
   - Oui: prend la première dépendance comme cible et recommence à 3.
   - Non: exécute la règle.

`make` a un comportement **récursif**.

# Exemple avancé

:::::::::::::: {.columns}

::: {.column width="55%"}

## `Makefile`

```bash
hello: hello.o main.o
    gcc hello.o main.o -o hello

hello.o: hello.c hello.h
    gcc -Wall -Wextra -c hello.c

main.o: main.c
    gcc -Wall -Wextra -c main.c

clean:
    rm -f *.o hello

rebuild: clean hello
```
:::
::: {.column width="45%"}

## Un graph complexe

![`Makefile` complexe.](figs/complex_makefile.svg){width=100%}

:::
::::::::::::::

# Factorisation

:::::::::::::: {.columns}

::: {.column width="55%"}
## Ancien `Makefile`

```bash
hello: hello.o main.o
    gcc hello.o main.o -o hello

hello.o: hello.c hello.h
    gcc -Wall -Wextra -c hello.c

main.o: main.c
    gcc -Wall -Wextra -c main.c

clean:
    rm -f *.o hello

rebuild: clean hello
```
:::
::: {.column width="45%"}

## Nouveau `Makefile`

```bash
CC=gcc -Wall -Wextra

hello: hello.o main.o
    $(CC) $^ -o $@

hello.o: hello.c hello.h
    $(CC) -c $<

main.o: main.c
    $(CC) -c $<

clean:
    rm -f *.o hello

rebuild: clean hello
```

:::
::::::::::::::

# Variables

## Variables utilisateur

- Déclaration
 
    ```bash
    id = valeur
    id = valeur1 valeur2 valeur3
    ```
- Utilisation
 
    ```bash
    $(id)
    ```
- Déclaration à la ligne de commande

    ```bash
    make CFLAGS="-O3 -Wall"
    ```

## Variables internes

- `$@` : la cible
- `$^` : la liste des dépendances
- `$<` : la première dépendance
- `$*` : le nom de la cible sans extension