Forcer les commandes dans les dépendances Makefile

Question

J'ai besoin d'aide pour écrire un makefile GNU. J'ai un programme C "main.c", qui dépend de la valeur de "CONSTANT" définie dans le fichier "constants.h".

"main.c"

#include <stdio.h> 
#include "constants.h" 

void work(void) 
{ 
    int array[CONSTANT]; 
    for (int i = 0; i < CONSTANT; i++) { 
     printf("%d\n", i); 
    } 
} 

int main(int argc, char const* argv[]) 
{ 
    printf("constant=%d\n", CONSTANT); 
    work(); 
    return 0; 
} 

"constant.h"

#ifndef CONSTANTS_H 
#define CONSTANTS_H 

#define CONSTANT 4 
#endif 

Ce que je suis en train de faire ici est de compiler le programme avec des valeurs différentes pour "CONSTANT". Par exemple, "out1" est compilé avec "CONSTANT = 1" et avec "make all", je devrais être capable de produire toutes les variantes ("out1", "out2" et "out4").

Le problème est que "a.o" requis par "main.c" dépend aussi de la valeur de "CONSTANT". Donc "a.o" doit être compilé après "sed%". Cependant, autant que je comprenne, il n'y a aucun moyen de "faire" pour forcer des ordres dans les dépendances (je suppose que c'est le point entier d'utiliser makefiles).

Quelle est la méthode recommandée pour remédier à cette situation?

« Makefile »

CC= gcc 
CFLAGS = -std=c99 -Wall 

CONSTANTS = 1 2 4 
targets = $(addprefix out, $(CONSTANTS)) 
seds = $(addprefix sed, $(CONSTANTS)) 

.PHONY: $(seds) 
$(seds): sed%: 
    sed -i 's/define CONSTANT [0-9]*/define CONSTANT $*/g' constants.h 

$(targets): out%: main.c sed% a.o 
    $(CC) $(CFLAGS) $< a.o -o $@ 

a.o: a.c constant.h 
    $(CC) $(CFLAGS) $< a.o -o $@ 

.PHONY: all 
all : $(targets) 

Notez que je suis conscient que je peux réécrire « main.c » pour qu'il prenne un paramètre de la ligne comman. En pratique, beaucoup d'autres fichiers que "main.c" dépendent de "CONSTANT", donc je veux éviter de réécrire tous ces fichiers. Je suis également conscient que je peux faire quelque chose comme "gcc-DCONSTANT = n main.c", mais chaque fichier dépendant de "CONSTANT" doit aussi être recompilé.

Questions connexes

• How to specify Makefile target building order without put any physical dependencies?

• Force order of dependencies in a Makefile

Answer 1

... Je suis conscient que je peux faire quelque chose comme « -DCONSTANT gcc = n principal. c ", mais chaque fichier dépendant de" CONSTANT "doit également être recompilé.

Cela ne doit pas être un obstacle si vous avez votre makefile générer le fichier objet -DCONSTANT=n et distinct correct dans chaque recette de compilation.

est ici une illustration:

constants.h

#ifndef CONSTANTS_H 
#define CONSTANTS_H 

#ifndef CONSTANT 
#define CONSTANT 4 
#endif 

#endif 

foo.c

#include "constants.h" 

int foo = CONSTANT; 

principale.c

#include <stdio.h> 
#include "constants.h" 

extern int foo; 

int main() 
{ 
    printf("%d\n",CONSTANT + foo); 
    return 0; 
} 

Makefile

CC := gcc 
CFLAGS := -std=c99 -Wall 

CONSTANTS = 1 2 4 
TARGETS = $(addprefix out, $(CONSTANTS)) 
SRCS := main.c foo.c 

define compile = 
$(basename $(1))$(2).o: $(1) constants.h 
    $$(CC) -c -DCONSTANT=$(2) $$(CFLAGS) $$< -o $$@ 
endef 

.PHONY: all clean 

all : $(TARGETS) 

$(foreach src,$(SRCS),\ 
    $(foreach const,$(CONSTANTS),$(eval $(call compile,$(src),$(const))))) 

out%: main%.o foo%.o 
    $(CC) $^ -o $@ 


clean: 
    rm -f $(TARGETS) *.o 

Cela fonctionne comme:

$ make 
gcc -c -DCONSTANT=1 -std=c99 -Wall main.c -o main1.o 
gcc -c -DCONSTANT=1 -std=c99 -Wall foo.c -o foo1.o 
gcc main1.o foo1.o -o out1 
gcc -c -DCONSTANT=2 -std=c99 -Wall main.c -o main2.o 
gcc -c -DCONSTANT=2 -std=c99 -Wall foo.c -o foo2.o 
gcc main2.o foo2.o -o out2 
gcc -c -DCONSTANT=4 -std=c99 -Wall main.c -o main4.o 
gcc -c -DCONSTANT=4 -std=c99 -Wall foo.c -o foo4.o 
gcc main4.o foo4.o -o out4 

et les programmes qui en résultent fonctionnent comme:

$ for i in 1 2 4; do ./out$i; done 
2 
4 
8