Differences

This shows you the differences between two versions of the page.

--- projtec:index [2016/09/12 19:11] – [Makefile] orel
+++ projtec:index [2024/03/18 15:06] (current) – external edit 127.0.0.1
@@ Line 3: / Line 3: @@
 //Vous trouverez sur ce wiki quelques notes personnelles sur l'UE Projets Technologiques en L2 Info.//
-__Site Web__ : https://moodle1.u-bordeaux.fr/course/view.php?id=2930
+  * [[projtec:gcc | GCC ]]
+  * [[projtec:make | Makefile ]]
+  * [[projtec:git | Git ]]
+  * [[projtec:test | Tests]]
+  * [[projtec:gdb | Débogage]]
+  * [[projtec:cmake | CMake ]]
+  * [[projtec:sdl2 | SDL2 ]]
+  * [[projtec:android | Android ]]
+  * [[projtec:ide | IDE ]]
-====Compilation====
-//Ici, nous nous intéressons uniquement à la compilation de programme C99 sous Linux avec le compilateur GNU.//
-Considérons un programme //hello.c// en un seul fichier.
-<code c hello.c>
-#include <stdio.h>
-int main(int argc, char* argv[]) {
-  printf("hello world!\n");
-  return 0;
-}
-</code>
-Pour rendre ce programme exécutable, il faut le compiler avec gcc:
-  gcc -std=c99 hello.c -o hello   # compilation
-  ./hello                         # exécution
-En fait, la ligne de compilation précédente est un raccourci. En principe, on distingue deux étapes, la compilation des fichiers sources (.c) en fichier objet (.o) et l'édition de lien qui combine les fichiers objets pour générer un exécutable. Ce qui donne :
-  gcc -std=c99 -c hello.c             # compilation (génère hello.o)
-  gcc hello.o -o hello                # édition de lien (génère l'exécutable hello)
-Supposons maintenant que notre programme se compose de plusieurs fichiers : le programme principal //toto.c// avec la fonction //main()// ainsi que plusieurs fichiers annexes //tutu.c// et //tata.c//. De plus, ce programme utilise la fonction //sqrt()// de la bibliothèque mathématique standard (libm.a). Pour compiler ce programme en ligne de commande, il faut d'abord générer tous les fichiers objets !
-  gcc -std=c99 -c toto.c tutu.c tata.c
-Puis, on réalise l'édition de lien sans oublier l'option "-lm" qui indique d'utiliser la bibliothèque statique //libm.a//, généralement disponible dans un répertoire standard du système (typiquement /usr/lib).
-  gcc toto.o tutu.o tata.o -o toto -lm
-Imaginons maintenant qu nous souhaitons regrouper les fichiers //tutu.c// et //tata.c// au sein d'une bibliothèque statique //libpouet.a//. La construction de bibliothèque permet de favoriser la "réutilisabilité" des fonctions d'une sous-partie du programme. Pour construire cette bibliothèque, il faut regrouper plusieurs fichiers objets au sein d'un archive :
-  ar rcs libpouet.a tutu.o tata.o
-On peut ensuite utiliser cette bibliothèque pour la compilation avec l'option '-lpouet' :
-  gcc toto.o -o toto -L. -lpouet -lm
-L'option '-L.' indique que le fichier libpouet.a est disponible dans le répertoire courant ('.').
-====Makefile====
-//Pour compiler automatiquement et efficacement un projet de programmation, le Makefile est une solution élégante.//
-Un fichier //Makefile// est un simple fichier texte qui définit un ensemble de régles, chaque règle permettant de générer un fichier cible à partir de ses dépendances (une liste de fichiers). Voici la syntaxe d'un règle :
-  cible1: dep1 dep2 dep3 ...
-      commande
-Attention, il faut une tabulation avant d'écrire la //commande// qui réalise la cible !
-Notons que la commande n'est exécutée que si le fichier //cible1// n'existe pas, ou que la cible est périmée, c'est-à-dire qu'il y a au moins une dépendance qui est plus récente que la cible. Dans ce dernier cas, il faut mettre à jour la cible. Par ailleurs, les dépendances peuvent également être la cible d'autres règles. Dans ce cas, si le fichier d'une dépendance comme //dep1// n'existe pas (ou qu'elle est périmée), alors on va appliquer cette autre règle en cascade pour mettre à jour cette dépendance, avant de mettre à jour //cible1//.
-  dep1: autredep1 autredep2 ...
-      autre_commande
-Au final, grâce à un chaînage précis des dépendances, le Makefile permet de re-compiler un projet en ne mettant à jour que les cibles qui dépendent des fichiers modifiés.
-Voici un exemple type de fichier Makefile pour le programme C précédent.
-<code bash Makefile>
-# variable standard pour la compilation
-CC=gcc                      # compilateur
-CFLAGS=-Wall -g -std=c99    # options de compilation
-LDFLAGS=-L. -lm             # options de link
-CPPFLAGS=                   # options de preprocessing
-# cible principale (par défaut)
-all: toto
-# règle spécifique pour générer l'exécutable
-toto: toto.o tutu.o tata.o
-	$(CC) $^ -o $@ $(LDFLAGS)
-# règle générique de compilation des fichiers C
-%.o: %.c
-	$(CC) $(CFLAGS) -c $< -o $@
-.PHONY: clean
-clean:
-	rm -f *.o *~ toto
-</code>
-Dans ce Makefile, il y a quelques notions à comprendre :
-  * Les commentaires sont précédés du symbole #.
-  * La variable %%$%%@ représente la cible courante.
-  * La variable %%$%%^ représente la liste des dépendances.
-  * La variable %%$%%< représente la première dépendance.
-  * La cible .PHONY permet d'indiquer des cibles particulières qui ne sont pas des fichiers, comme par exemple //clean//.
-Pour fabriquer une cible particulière, on fait //make cible//. Par défault, l'appel à //make// fabrique la première cible (//all// dans notre exemple.
-<code bash>
-$ make
-gcc -Wall -g -std=c99 -c toto.c -o toto.o
-gcc -Wall -g -std=c99 -c tutu.c -o tutu.o
-gcc -Wall -g -std=c99 -c tata.c -o tata.o
-gcc toto.o tutu.o tata.o -o toto -L. -lm
-$ make clean
-rm -f *.o *~ toto
-</code>
-//Expliquer comment injecter automatiquement des dépendances complexes dans un Makefile grâce à l'option '-MM'de gcc.//