Discussion :

[pfeuh]

Salut,

Malgré plusieurs relecture du tutoriel sur le makefile, je ne m'en sors pas, impossible d'avoir le moindre déclic. Je pose le contexte:

Mon premier ordinateur fut un Atari 800, j'ai fait beaucoup d'assembleur dans les années 80. Je viens de trouver cc65, un des très rares compilos pour le 6502 de l'Atari, ce qui relance bien sûr mon intérêt pour ce dinosaure. Je fais le "hello world" en invoquant à la main le compilateur et le linkeur, j'obtiens mon fichier exécutable que je pose sur une image disque pour un émulo Atari et ça marche nickel.

Le principe de cc65, c'est un compilo et un linker séparés. On invoque le compilo qui transforme les sources C en asm, puis le linker qui traite tous les asm pour produire le fichier exécutable.

pour compiler un hello word:
cc65 -t atari -o hello.s hello.c
on cree le source assembleur hello.s à partir du source C hello.c pour la cible atari

pour le linker:
cl65 -t atari -o hello.com hello.s
on cree le fichier exécutable hello.com à partir du source asm hello.s pour la cible atari

Rien d'inhabituel, je pense, enfin rien qui ne me choque. Plutôt que de toujours faire à la main, j'aimerai faire un makefile, d'autant que pour ce genre de cible on mélange allègrement C et assembleur et que j'aime bien utiliser codeblocks qui offre la possibilité de rajouter un compilo et d'avoir un makefile custom. Donc, n'ayant rien compris au makefile (il y en a bien un exemple livré avec cc65, dans le répertoire des samples de code, mais ça reste du chinois pour moi), j'ai plusieurs questions qui me viennent:

Peut on donner au makefile une liste de fichiers C à compiler puis une liste de fichiers asm à linker? Et si oui, comment? Sachant que les asm sont plus nombreux que les fichiers C, donc les listes sont différentes.

A+

Pfeuh

[Obsidian]

Hello,

Peut on donner au makefile une liste de fichiers C à compiler puis une liste de fichiers asm à linker? Et si oui, comment? Sachant que les asm sont plus nombreux que les fichiers C, donc les listes sont différentes.

Oui. À vrai dire, tu peux utiliser les Makefiles à n'importe quoi. Même pour produire des fichiers qui ne soient pas issus d'un langage de programmation à proprement parler. Le principe de base est très simple :

Code Makefile :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
cible: dependance1 dependance2 …
        commande

Lorsque tu vas appeler « make », le programme va analyser le contenu de Makefile pour tenter de bâtir la cible que tu lui as passée en argument ou, à défaut, la première qu'il va rencontrer. Ensuite, le processus est le suivant :

• « cible » est le nom exact du fichier à produire. S'il existe déjà et s'il n'a pas de dépendances, alors make estime que la cible est à jour, et s'arrête là ;
• Si elle n'a pas de dépendance, et que le fichier cible n'existe pas, alors make appelle « commande » pour la générer (et s'arrête là) ;
• Si « cible » a des dépendances, alors make va vérifier si les fichiers portant le nom de chaque dépendance, respectivement, existent et portent une date de dernière modification antérieure à celle de la cible. Ces dates sont celles du système de fichiers. Si c'est le cas, là encore, make considère la cible à jour et s'arrête ;
• Si au moins une des dépendances affiche une date de dernière modification plus récente, c'est qu'elle a été mise à jour depuis la création de la cible. make appelle alors « commande » pour regénérer la cible, en cascade ;
• Si au moins un fichier de dépendance est manquant, alors make se réappeler lui-même, récursivement, à la recherche d'une cible portant le nom de la dépendance, la générer s'il y arrive, puis va reprendre le processus là où il en était en cas de succès.

Au niveau de la syntaxe: une cible est alignée sur la première colonne dans le Makefile et immédiatement suivi d'un « : », puis des éventuelles dépendances. Les commandes associées viennent juste en dessous, sans ligne vide, et commencent toutes par une tabulation. Le reste est dans le tutoriel.

Par rapport à script ordinaire, « make » sert donc principalement à gérer les dépendances entre les différents éléments d'un projet et à ne re-générer que ce qui est nécessaire. Tu peux donc t'en servir à presque n'importe quoi, comme par exemple re-générer des documents à partir de fichiers *.lex par exemple, ou autres.

[souviron34]

• « cible » est le nom exact du fichier à produire. S'il existe déjà et s'il n'a pas de dépendances, alors make estime que la cible est à jour, et s'arrête là ;

euh..

Petite précision :

une cible dans un Makefile est délimitée par "::" ou ":" et ne consiste pas du tout en un nom exact de fichier, mais l'équivalent d'un "label" dans un programme..

A ce label, on va ensuite préciser quelles sont les opérations à faire.

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
...
tout:: all
..
all:: clean monsave monexe monprint
 
clean:: 
	cd $(OBJECT_DIR); rm -f $(OBJS) ; cd $(SOURCE_DIR) ; rm -f *~; cd $(PWD);
 
monexe::
	$(CC) $(CFLAGS) $(SOURCE_DIR)MonSource.c  -lm -o $(EXE_DIR)MonExe
 
monsave::
	@echo "Copie de la vieille version dans .old"
	mv -f $(EXE_DIR)/MonExe $(EXE_DIR)/MonExe.old
 
monprint::
	@echo "Nouvelle version installée"

What a Rule looks like

A target is usually the name of a file that is generated by a program; examples of targets are executable or object files. A target can also be the name of an action to carry out, such as ‘clean’

[pfeuh]

Je vous remercie, j'y vois un peu plus clair. Pour la deuxième question, il semble donc que le makefile soit différent pour chaque projet et qu'un ide comme codeblocks ou eclipse le reconstruise dynamiquement en fonctions des sources ajoutés ou enlevés du projet (codeblocks) ou des sources présents dans le répertoire du projet (eclipse)?

Donc dans le cas qui m'intéresse(codeblocks) il faut que j'écrive et que je mette dans le preprocessing un programme qui parse le répertoire courant, qui fasse la liste de tous les .c et tous les .asm, et qui me génère un makefile en fonction de ces listes?

[souviron34]

Donc dans le cas qui m'intéresse(codeblocks) il faut que j'écrive et que je mette dans le preprocessing un programme qui parse le répertoire courant, qui fasse la liste de tous les .c et tous les .asm, et qui me génère un makefile en fonction de ces listes?

Pourquoi faire compliqué ?

Un copié-collé des bonnes lignes de l'explorateur sans les détails ne serait pas plus simple ?

[pfeuh]

Un copié-collé des bonnes lignes de l'explorateur sans les détails ne serait pas plus simple ?

Si bien sûr, mais la simplicité n'est pas ce que je recherche. Je voudrais plutôt pouvoir rajouter des .c et des .asm par la fonction 'append files to project' de codeblocks sans plus jamais me préoccuper du makefile. Je pense donc que le jeu en vaut la chandelle. Et du coup que pour faire souvent simple, il faut faire une fois compliqué.

[souviron34]

tu peux directement dans le Makefile utiliser des "*", voir le pâragraphe concerné dans le document cité ci-dessus : Using Wildcards in File Names

tu peux donc faire "*.c" ou "*.asm".

D'ailleurs, pour établir une règle de compilation, tu la précises telle que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
#---------------------------------------------------
#
#  Directives pour la compilation
#
#---------------------------------------------------
 
.c.o:
	$(CC) $(CFLAGS)  $(INC_DIR) -c $< $(LDFLAGS)

tu peux donc choisir les flags que tu veux au travers des varaibles pour obtenir directement un traitement global..

[pfeuh]

Super, merci. Je clos le sujet.

A+

Pfeuh