Come stampare una variabile in makefile

Nel mio makefile, ho una variabile 'NDK_PROJECT_PATH', la mia domanda è come posso stamparlo quando viene compilato?

Ho letto Make echo file visualizzando la stringa "$ PATH" e ho provato:

@echo $(NDK_PROJECT_PATH)
@echo $(value NDK_PROJECT_PATH)

Entrambi mi danno

"build-local.mk:102: *** missing separator.  Stop."

Qualcuno sa perché non funziona per me?

Puoi stampare le variabili mentre il makefile viene letto (supponendo che GNU make abbia taggato questa domanda in modo appropriato) usando questo metodo (con una variabile chiamata "var"):

$(info $$var is [${var}])

Puoi aggiungere questo costrutto a qualsiasi ricetta per vedere quale marca passerà alla shell:

.PHONY: all
all: ; $(info $$var is [${var}])echo Hello world

Ora, ciò che accade qui è che memorizza l'intera ricetta ( $(info $$var is [${var}])echo Hello world) come singola variabile espansa ricorsivamente. Quando make decide di eseguire la ricetta (ad esempio quando le dici di compilare all), espande la variabile e quindi passa ciascuna riga risultante separatamente alla shell.

Quindi, nei dettagli dolorosi:

• Si espande $(info $$var is [${var}])echo Hello world
• Per fare ciò si espande prima $(info $$var is [${var}])
  • $$ diventa letterale $
  • ${var}diventa :-)(diciamo)
  • L'effetto collaterale è che $var is [:-)]appare fuori standard
  • L'espansione del $(info...)pensiero è vuota
• Make è rimasto con echo Hello world
  • echo Hello worldPrima fai stampe su stdout per farti sapere cosa chiederà alla shell di fare
• La shell stampa Hello worldsu stdout.

Come da GNU Make manual e anche indicato da 'bobbogo' nella risposta qui sotto, puoi usare info / warning / error per visualizzare il testo.

$(error   text…)
$(warning text…)
$(info    text…)

Per stampare variabili,

$(error   VAR is $(VAR))
$(warning VAR is $(VAR))
$(info    VAR is $(VAR))

'errore' interrompe l' esecuzione di make , dopo aver mostrato la stringa di errore

da un "Mr. Make post" https://www.cmcrossroads.com/article/printing-value-makefile-variable

Aggiungi la seguente regola al tuo Makefile:

print-%  : ; @echo $* = $($*)

Quindi, se vuoi scoprire il valore di una variabile makefile, basta:

make print-VARIABLE

e restituirà:

VARIABLE = the_value_of_the_variable

Se vuoi semplicemente un po 'di output, vuoi usarlo $(info)da solo. Puoi farlo ovunque in un Makefile e mostrerà quando viene valutata quella linea:

$(info VAR="$(VAR)")

Produrrà VAR="<value of VAR>"ogni volta che trasformi i processi in quella linea. Questo comportamento dipende molto dalla posizione, quindi è necessario assicurarsi che l' $(info)espansione avvenga DOPO che tutto ciò che potrebbe essere modificato $(VAR)sia già avvenuto!

Un'opzione più generica è quella di creare una regola speciale per la stampa del valore di una variabile. In generale, le regole vengono eseguite dopo l'assegnazione delle variabili, quindi questo mostrerà il valore effettivamente utilizzato. (Tuttavia, è possibile che una regola cambi una variabile .) Una buona formattazione aiuterà a chiarire su cosa è impostata una variabile e la $(flavor)funzione ti dirà che tipo di variabile è qualcosa. Quindi in questa regola:

print-% : ; $(info $* is a $(flavor $*) variable set to [$($*)]) @true

• $*si espande allo stelo che il % modello corrisponde alla regola.
• $($*)si espande al valore della variabile il cui nome è dato da $*.
• Il [e ]chiaramente delineare l'espansione variabile. Puoi anche usare "e / "o simili.
• $(flavor $*)ti dice che tipo di variabile è. NOTA: $(flavor) prende un nome variabile e non la sua espansione. Quindi, se dici make print-LDFLAGS, ottieni $(flavor LDFLAGS), che è quello che vuoi.
• $(info text)fornisce output. Realizza stampe textsul suo stdout come effetto collaterale dell'espansione. L'espansione di $(info)però è vuota. Puoi pensarlo come @echo, ma soprattutto non usa la shell, quindi non devi preoccuparti delle regole di quotazione della shell.
• @truec'è solo per fornire un comando per la regola. Senza questo, anche make verrà prodotto print-blah is up to date. Sento che @truerende più chiaro che è pensato per essere un non-op.

Eseguendolo, ottieni

$ make print-LDFLAGS
LDFLAGS is a recursive variable set to [-L/Users/...]

@echo $ (NDK_PROJECT_PATH) è il modo migliore per farlo. Non credo che l'errore provenga da lì. Generalmente questo errore appare quando hai sbagliato a digitare l'intenzione: penso che tu abbia spazi in cui dovresti avere una scheda.

Tutte le versioni di makerichiedono che le righe di comando siano rientrate con una TAB (non spazio) come primo carattere della riga. Se ci mostrassi l'intera regola anziché solo le due righe in questione, potremmo dare una risposta più chiara, ma dovrebbe essere qualcosa del tipo:

myTarget: myDependencies
        @echo hi

dove il primo carattere nella seconda riga deve essere TAB.

Corri make -n; ti mostra il valore della variabile ..

Makefile ...

all:
        @echo $(NDK_PROJECT_PATH)

Comando:

export NDK_PROJECT_PATH=/opt/ndk/project
make -n 

Produzione:

echo /opt/ndk/project

Questo makefilegenererà il messaggio di errore "separatore mancante":

all
    @echo NDK_PROJECT_PATH=$(NDK_PROJECT_PATH)

done:
        @echo "All done"

C'è una scheda prima del @echo "All done"(sebbene la done:regola e l'azione siano in gran parte superflue), ma non prima del @echo PATH=$(PATH).

Il problema è che la linea di partenza alldovrebbe avere due punti :o uguale =a indicare che si tratta di una linea di destinazione o di una linea macro, e non ha nessuno dei due, quindi manca il separatore.

L'azione che fa eco al valore di una variabile deve essere associata a un target, possibilmente un target fittizio o PHONEY. E quella linea di destinazione deve avere due punti su di essa. Se aggiungi un :after allnell'esempio makefilee sostituisci gli spazi vuoti iniziali nella riga successiva con una scheda, funzionerà in modo sicuro.

Probabilmente hai un problema analogo vicino alla linea 102 dell'originale makefile. Se sono state visualizzate 5 righe non vuote e non commentate prima delle operazioni di eco che non riescono, probabilmente sarebbe possibile completare la diagnosi. Tuttavia, dal momento che la domanda è stata posta a maggio 2013, è improbabile che l'interruzione makefilesia ancora disponibile ora (agosto 2014), quindi questa risposta non può essere validata formalmente. Può essere utilizzato solo per illustrare un modo plausibile in cui si è verificato il problema.

Non è necessario modificare il Makefile.

$ cat printvars.mak
print-%:
        @echo '$*=$($*)'

$ cd /to/Makefile/dir
$ make -f ~/printvars.mak -f Makefile print-VARIABLE

Il problema è che l'eco funziona solo con un blocco di esecuzione. cioè qualsiasi cosa dopo "xx:"

Quindi qualsiasi cosa al di sopra del primo blocco di esecuzione è solo l'inizializzazione, quindi non è possibile utilizzare alcun comando di esecuzione.

Quindi crea un blocco di esecuzione

Questo può essere fatto in modo generico e può essere molto utile durante il debug di un makefile complesso. Seguendo la stessa tecnica descritta in un'altra risposta , è possibile inserire quanto segue in qualsiasi makefile:

# if the first command line argument is "print"
ifeq ($(firstword $(MAKECMDGOALS)),print)

  # take the rest of the arguments as variable names
  VAR_NAMES := $(wordlist 2,$(words $(MAKECMDGOALS)),$(MAKECMDGOALS))

  # turn them into do-nothing targets
  $(eval $(VAR_NAMES):;@:))

  # then print them
  .PHONY: print
  print:
          @$(foreach var,$(VAR_NAMES),\
            echo '$(var) = $($(var))';)
endif

Quindi puoi semplicemente fare "make print" per scaricare il valore di qualsiasi variabile:

$ make print CXXFLAGS
CXXFLAGS = -g -Wall

Puoi creare una regola vars nel tuo file make, in questo modo:

dispvar = echo $(1)=$($(1)) ; echo

.PHONY: vars
vars:
    @$(call dispvar,SOMEVAR1)
    @$(call dispvar,SOMEVAR2)

Ci sono alcuni modi più robusti per scaricare tutte le variabili qui: gnu make: elenca i valori di tutte le variabili (o "macro") in una determinata esecuzione .

Se non si desidera modificare il Makefile stesso, è possibile utilizzare --evalper aggiungere un nuovo target e quindi eseguire il nuovo target, ad es.

make --eval='print-tests: @echo TESTS $(TESTS) ' print-tests

È possibile inserire il carattere TAB richiesto nella riga di comando utilizzando CTRL-V, TAB

esempio Makefile dall'alto:

all: do-something

TESTS=
TESTS+='a'
TESTS+='b'
TESTS+='c'

do-something:
        @echo "doing something"
        @echo "running tests $(TESTS)"
        @exit 1

se usi android make (mka) @echo $(NDK_PROJECT_PATH)non funzionerà e ti darà un errore *** missing separator. Stop." usa questa risposta se stai provando a stampare variabili in android make

NDK_PROJECT_PATH := some_value
$(warning $(NDK_PROJECT_PATH))

ha funzionato per me

Di solito echo con un errore se volevo vedere il valore della variabile (solo se volevi vedere il valore. Arresterà l'esecuzione).

@echo $ (errore NDK_PROJECT_PATH = $ (NDK_PROJECT_PATH))