Accoda a GNU crea variabili tramite la riga di comando

Question

Sto utilizzando un Makefile GNU per creare un progetto C con più destinazioni (all, clean e alcuni obiettivi specifici del progetto). Nel processo di debug, vorrei aggiungere alcuni flag a una singola build senza modificare permanentemente il Makefile (ad esempio aggiungere i simboli di debug o impostare un flag del preprocessore).

In passato, ho fatto come segue (utilizzando l'esempio simboli di debug):

make target CFLAGS+=-g 

Purtroppo, questo non è aggiungendo alla variabile CFLAGS, ma, invece, di compensazione e impedendogli di compilazione . C'è un modo pulito per farlo senza definire una sorta di variabile fittizia aggiunta alla fine di CFLAGS e LDFLAGS?

Answer 1

Controlla il override directive. Probabilmente avrai bisogno di modificare il makefile una volta, ma dovrebbe fare quello che vuoi.

Esempio makefile:

override CFLAGS += -Wall 

app: main.c 
    gcc $(CFLAGS) -o app main.c 

Esempio righe di comando:

$ make 
gcc -Wall -o app main.c 
$ make CFLAGS=-g 
gcc -g -Wall -o app main.c 

Answer 2

Per la cronaca, del @Carl Norum risposta antepone variabile, dal punto di vista linea di comando.

avevo bisogno di un modo per aggiungere in realtà e si avvicinò con:

override CFLAGS := -Wall $(CFLAGS) 

Answer 3

Solo una nota, come io sono confuso - lasciate che questo essere un file testmake:

$(eval $(info A: CFLAGS here is $(CFLAGS))) 

override CFLAGS += -B 

$(eval $(info B: CFLAGS here is $(CFLAGS))) 

CFLAGS += -C 

$(eval $(info C: CFLAGS here is $(CFLAGS))) 

override CFLAGS += -D 

$(eval $(info D: CFLAGS here is $(CFLAGS))) 

CFLAGS += -E 

$(eval $(info E: CFLAGS here is $(CFLAGS))) 

Poi:

$ make -f testmake 
A: CFLAGS here is 
B: CFLAGS here is -B 
C: CFLAGS here is -B 
D: CFLAGS here is -B -D 
E: CFLAGS here is -B -D 
make: *** No targets. Stop. 
$ make -f testmake CFLAGS+=-g 
A: CFLAGS here is -g 
B: CFLAGS here is -g -B 
C: CFLAGS here is -g -B 
D: CFLAGS here is -g -B -D 
E: CFLAGS here is -g -B -D 
make: *** No targets. Stop. 

Con le direttive override eliminate dal file testmake:

$ make -f testmake 
A: CFLAGS here is 
B: CFLAGS here is -B 
C: CFLAGS here is -B -C 
D: CFLAGS here is -B -C -D 
E: CFLAGS here is -B -C -D -E 
make: *** No targets. Stop. 
$ make -f testmake CFLAGS+=-g 
A: CFLAGS here is -g 
B: CFLAGS here is -g 
C: CFLAGS here is -g 
D: CFLAGS here is -g 
E: CFLAGS here is -g 
make: *** No targets. Stop. 

Quindi,

• se una variabile utilizzata override una volta, può essere aggiunto soltanto con un'altra dichiarazione con override (le assegnazioni normali saranno ignorati);
• quando non c'è stato nessuno override; provare ad aggiungere (come in +=) dalla riga di comando sovrascrive ogni istanza di quella variabile.

Answer 4

Ci sono due modi per passare le variabili per rendere:

• utilizzando gli argomenti della riga di comando:

  make VAR=value 
  

• Usando ambiente:

  export VAR=var; make 
  

  o (meglio perché cambia ambiente solo per i comuni correnti d)

  VAR=var make 
  

Essi sono leggermente diverse. Il primo è più forte. Significa che sai quello che vuoi. Il secondo può essere considerato come un suggerimento. La differenza tra loro riguarda gli operatori = e += (senza override). Questi operatori vengono ignorati quando una variabile viene definita sulla riga di comando, ma non vengono ignorati quando la variabile viene definita nell'ambiente. Quindi, vi suggerisco di avere un Makefile con:

CC ?= gcc 
    CFLAGS += -Wall 
    INTERNAL_VARS = value 

e chiamarlo con:

CFLAGS=-g make 

Avviso, se si desidera ritirare -Wall, è possibile utilizzare:

make CFLAGS= 

Si prega di non utilizzare la parola chiave override, altrimenti non si avrà alcun modo di modificare una variabile interessata con override.