Über die Befehlszeile an GNU-Make-Variablen anhängen

Question 1

Ich verwende ein GNU-make-Makefile, um ein C-Projekt mit mehreren Zielen zu erstellen (all, clean, und einige projektspezifische Ziele). Während des Debuggens möchte ich einige Flags an einen einzelnen Build anhängen, ohne das Makefile dauerhaft zu bearbeiten (z. B. Debugging-Symbole hinzufügen oder ein Präprozessor-Flag setzen).

In der Vergangenheit habe ich das wie folgt gemacht (am Beispiel der Debugging-Symbole):

make target CFLAGS+=-g

Leider ist dies kein Anhang an die CFLAGS -Variable, sondern löschen sie stattdessen und verhindern, dass sie kompiliert wird. Gibt es eine saubere Möglichkeit, dies zu tun, ohne eine Art Dummy-Variable zu definieren, die an das Ende von angehängt wird? CFLAGS und LDFLAGS?

Question 2

Probier das aus Direktive überschreiben. Sie müssen das Makefile wahrscheinlich einmal ändern, aber es sollte tun, was Sie wollen.

Beispiel-Makefile:

override CFLAGS += -Wall

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

Beispielbefehlszeilen:

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

Question 3

Fürs Protokoll, die Antwort von @Carl Norum vorangestellt die Variable aus der Kommandozeilenperspektive.

Ich brauchte einen Weg, um tatsächlich anzuhängen, und kam auf:

override CFLAGS := -Wall $(CFLAGS)

Question 4

Es gibt zwei Möglichkeiten, Variablen an make zu übergeben:

Verwenden von Befehlszeilenargumenten:
```
make VAR=value
```
Umgebung verwenden:
```
export VAR=var; make
```
oder (besser, weil es die Umgebung nur für den aktuellen Befehl ändert)
```
VAR=var make
```

Sie sind etwas anders. Der erste ist stärker. Es bedeutet, dass Sie wissen, was Sie wollen. Der zweite kann als Hinweis betrachtet werden. Der Unterschied zwischen ihnen liegt in den Operatoren = und += (ohne override). Diese Operatoren werden ignoriert, wenn eine Variable in der Befehlszeile definiert wird, werden jedoch nicht ignoriert, wenn die Variable in der Umgebung definiert wird. Daher schlage ich vor, dass Sie ein Makefile haben mit:

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

und rufe es auf mit:

CFLAGS=-g make

Beachten Sie, wenn Sie sich zurückziehen möchten -Wallkönnen Sie verwenden:

make CFLAGS=

Bitte nicht verwenden override Schlüsselwort, sonst haben Sie keine Möglichkeit, eine betroffene Variable zu ändern override.

Question 5

Nur eine Anmerkung, da ich verwirrt war – lassen Sie dies eine Datei sein 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)))

Dann:

$ 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.

Mit dem override Richtlinien aus der gelöscht testmake Datei:

$ 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.

So,

wenn eine Variable verwendet wird override einmal kann es nur mit einer weiteren Anweisung mit angehängt werden override (die normalen Zuweisungen werden ignoriert);
wenn es keine gab override überhaupt; versucht anzuhängen (wie in +=) über die Befehlszeile überschreibt jede Instanz dieser Variablen.