makepp_variables - Online nel cloud

PROGRAMMA:

NOME

makepp_variables -- Come usare le variabili in makepp

DESCRIZIONE

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAG,
COME, C: DC,
FLAG,
"cambiate_dipendenze",
input_modificati,
CURDIR,
CXX,
CXXFLAG, D: "dipendenze",
"dipendenza", F: F77,
frequenza cardiaca,
"per ciascuno", I: ingresso,
ingressi, L: LD,
LEX,
STRUMENTO LIBERO, M: FARE,
FARECMDGOALS,
MAKEFLAG,
INFORMAZIONE,
MAKEPP_DEBUG,
MAKEPPFLAG,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSIONE, O: "produzione",
"uscite", P: PERLA,
PWD, R: RM,
RADICE, S: GUSCIO,
"ordinate_dipendenze",
input_ordinati,
"stelo", T: bersaglio,
obiettivi, V: VPATH, Y: YACC

I makefile in genere utilizzano variabili in molti posti. Un motivo importante per l'utilizzo
variabili è garantire che le informazioni siano contenute in un solo posto nel makefile, quindi
che se cambia, non c'è pericolo che le due copie dell'informazione escano da
sync.

I nomi delle variabili fanno distinzione tra maiuscole e minuscole. In teoria, i nomi delle variabili possono essere composti da molti
caratteri, ma makepp probabilmente non sarà in grado di grok se fai qualcosa di diverso da
caratteri alfanumerici, "_" e "-".

Ogni makefile ha il proprio set di variabili e l'impostazione di una variabile in un makefile lo farà
non hanno effetto sul suo valore in nessun altro makefile. Se vuoi avere le variabili impostate in
molti makefile, il modo migliore per farlo è che ognuno di essi includa una definizione comune
file (vedere l'istruzione include) o utilizzare le variabili "globali".

Variabile Assegnazione
Una variabile può assumere un valore in diversi modi:

· Una variabile può essere impostata all'interno di un makefile. Ci sono diversi modi per farlo
questo; vedi sotto.

· Il valore di una variabile può essere specificato sulla riga di comando, in questo modo:

makepp CFLAGS=-O2 mio_programma

Se viene caricato più di un makefile, la variabile CFLAGS viene propagata a tutti i
makefile. Le variabili impostate sulla riga di comando sovrascrivono automaticamente qualsiasi impostazione di
la variabile in uno qualsiasi dei makefile.

Se mai necessario, il makefile deve a sua volta sovrascrivere esplicitamente le impostazioni della riga di comando.
L'intenzione non è ignorare ciò che l'utente richiede, ma piuttosto un modo per modificarlo.
Il modificatore "override" può precedere qualsiasi istruzione di assegnazione. Ma nel caso di
parole chiave, l'ordine è importante, motivo per cui la variante di override è
sempre mostrato di seguito. Il modificatore "override" si applica solo a tutte le assegnazioni in cui
è presente e non influenza le assegnazioni successive alla variabile.

· Se una variabile è impostata nell'ambiente, può essere referenziata come variabile makepp.
Normalmente le assegnazioni alle variabili all'interno di un makefile sovrascrivono le impostazioni da
ambiente, ma è possibile modificarlo utilizzando "-e" o "--environment-overrides"
opzione da linea di comando.

Le variabili sono assegnate con una delle diverse espressioni di assegnazione, come questa

X = 1
MODULI := abcd
CC ?= gcc
CFLAGS += -Parete
definire VAR
var linea 1
var linea 2
def
esportazione PERCORSO := $(PWD):$(PERCORSO)
global MYPROJECT.INFO = info da vedere in tutti i makefile

Gli spazi bianchi iniziali e finali attorno ai valori vengono sempre eliminati.

I diversi operatori di assegnazione hanno significati leggermente diversi.

Un'espansione assegnazione Operatori

=
VARIABILE = stringa di testo
sovrascrivere VARIABILE = stringa di testo

Questa è la solita istruzione di assegnazione supportata da tutte le implementazioni di make. Il
l'espressione a destra non viene valutata finché il valore di "$(VARIABLE)" è
effettivamente usato da qualche parte. Pertanto, se fai quanto segue:

X = 1
Y = $(X)
X = 2

Quindi "$(Y)" più avanti nel makefile valuterà "2".

In generale, di solito vuoi usare ":=" (vedi sotto) invece di "=" perché
fornisce una valutazione delle variabili più prevedibile. Tuttavia, ci sono momenti in cui hai bisogno
rinviare la valutazione della variabile. Inoltre, se stai scrivendo un makefile che deve essere
retrocompatibile con qualche versione di make diversa da GNU make, allora non hai
scelta: puoi usare solo "=".

:=
VARIABILE := espr
override VARIABILE := espr

Questo è lo stesso di "VARIABLE = expr" tranne per il fatto che viene valutato il lato destro
una volta per tutte al momento dell'incarico. Quindi se

X: = 1
Y := $(X)
X: = 2

quindi "$(Y)" più avanti nel makefile valuterà "1" poiché è quello che era "$(X)"
quando è stato definito "$(Y)".

;=
VARIABILE ;= espr
override VARIABILE ;= espr

È lo stesso di "VARIABLE := expr" tranne per il fatto che viene valutato il lato destro
solo al momento del primo utilizzo e poi ricordato. Questo è utile per i costosi
comandi, che restituiscono sempre lo stesso valore, ma che non vuoi eseguire quando
costruire obiettivi non correlati:

VAR1 ;= $(calcoli costosi perl)
VAR2 ;= $(comando esterno shell)

Nota che i vecchi makefile di solito usano ":=" qui, per farlo almeno una volta sola.
Ma con questo operatore puoi anche non farlo, se attualmente non lo fai
bisogno del valore. Per valori identici in più directory, è possibile
ottimizzalo ulteriormente con "globale", discusso di seguito.

Tuttavia, questo non è inteso come un modo intelligente per forzare l'ordine di valutazione. Se un
variabile definita in questo modo include il valore di un'altra variabile e quell'altra
ha un valore specifico per il target e la prima espansione è per quel target, quindi il
il valore specifico del target si attaccherà anche a tutti gli altri contesti. Questo è un bug e
si spera venga risolto in futuro.

+=
VARIABILE += espr
override VARIABILE += espr

Aggiunge la stringa al contenuto precedente della variabile, separato da uno spazio. Se
la variabile è stata precedentemente assegnata con ":=", quindi viene valutata la parte destra
prima di aggiungere.

&=
VARIABILE &= espr
override VARIABILE &= espr

Antepone la stringa al contenuto precedente della variabile, separato da uno spazio.
Se la variabile è stata precedentemente assegnata con ":=", allora il lato destro è
valutata prima di allegare.

Ad esempio un modo per garantire che "CFLAGS", qualunque altra cosa l'utente possa inserire,
inizia sempre con "-Wall" sono queste due righe:

CFLAGS = -O2 # Possibilmente sovrascritto sulla riga di comando
override CFLAGS &= -Wall # Anteposto incondizionatamente

Nei vecchi makefile in genere dovevi fare qualcosa del genere, che aveva il lato
effetto di forzare il tipo a ":=" per impedire una ricorsione infinita:

VARIABILE := expr $(VARIABILE)

?=
VARIABILE ?= espr
override VARIABLE ?= expr # Inutile, ma legale

Imposta il valore della variabile, ma solo se la variabile non è stata specificata in precedenza in
il makefile, sulla riga di comando o nell'ambiente. L'incarico di cui sopra è
esattamente equivalente a

ifndef VARIABILE
VARIABILE = espr
endif

!=
VARIABILE != comando di shell
override VARIABLE != comando shell

Esegue il comando shell e imposta la variabile in modo che contenga l'output standard del comando.
Questo è esattamente equivalente a

VARIABILE := $(comando shell)

Multilinea variabili

L'istruzione "define" è l'equivalente multilinea delle istruzioni semplici sopra. Il
operatore dopo la variabile è facoltativo. Se manca, equivale a "definire VARIABILE
=". Gli operatori "&=" e "+=" sono leggermente diversi qui, in quanto lo incollano a
il vecchio valore con una nuova riga, anziché uno spazio. Non ci deve essere nulla tranne a
commento dopo l'istruzione, ovvero il valore inizia nella riga successiva.

definire VARIABILE :=
prima riga del valore della variabile
seconda riga del valore della variabile
terza riga del valore della variabile
fine

sovrascrivere definire VARIABILE
...
def

Le parole chiave prima di "definire" possono essere combinazioni di "esporta" o "globale" e
"oltrepassare".

Se hai bisogno che il valore di una variabile contenga nuove righe, devi usare l'istruzione "define" come
mostrato (oppure puoi assegnare il valore direttamente in Perl). ("endef" è stato scelto per
compatibilità con GNU make. Puoi anche usare "enddef".) Questo è principalmente utile per
"sequenze di comandi predefinite", ad esempio, qualcosa del genere:

definire COMPILE_C_PROGRAM
@&echo "Compilazione $(input)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDE) -c $(input) -o $(output)
fine

Quindi puoi usare questa variabile multilinea in diverse regole, come questa:

%.o: %.c
$(COMPILE_C_PROGRAMMA)

$(ARCH)/%.o : $(ARCH)/%.c
$(COMPILE_C_PROGRAMMA)

Nota che spesso puoi ottenere lo stesso effetto usando un punto e virgola invece di una nuova riga,
perché la shell lo interpreta anche come delimitatore di comando. Per esempio,

COMPILE_C_PROGRAM = @echo "Compilazione $(input)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDE) -c $(input) -o $(output)

avrà lo stesso effetto, tranne per il fatto che il punto e virgola costringe Perl a passarlo alla shell,
invece di eseguire il comando direttamente e in modo più efficiente. Devi anche mettere ciascuno
integrato su una linea a parte, il che significa che devi passare all'eco esterno nel
caso di punto e virgola.

C'è una specialità quando si espande all'interno di "define", cioè "define X :=" o su a
variabile che era già ":=", "define X &=" e "define X +=". In questo caso il
"$(shell command ...)" o builtin "$(&command ...)" non trasformano le nuove righe in
spazi.

Esportazione variabili a sottoprocessi

esporta VAR...
export VAR = valore
sovrascrivere export VAR += valore

La prima forma contrassegna le variabili date per l'esportazione in sottoprocessi, con qualsiasi valore
la variabile allora ha. La seconda forma, che si applica solo a una variabile, inoltre
assegna subito un valore. Sono ammesse tutte le varianti di assegnazione.

Sharing variabili operanti in makefile

VAR globale...
VAR globale = valore
sovrascrivere VAR globale &= valore

La prima forma contrassegna le variabili date come globali per tutti i makefile. Se qualcuno di loro
aveva già un valore, quel valore viene spostato dalla variabile locale del makefile a quella globale
uno. Tuttavia se, al momento in cui viene visualizzata questa affermazione, qualsiasi altro makefile aveva già un
value per nessuno di essi, allora quei makefile non vedranno quello globale.

La seconda forma, che si applica solo a una variabile, assegna inoltre un valore right
via. Sono ammesse tutte le varianti di assegnazione. Nota che ":=" si espanderà subito
ai valori nel makefile locale. Al contrario le variabili "=" si espanderanno al
valori al momento dell'uso.

Le variabili globali possono essere difficili da gestire, perché makepp può caricare i makefile in qualsiasi
order, in quanto si presenta la necessità di costruire un target per il quale non vengono caricate regole o makefile.
Per questo motivo si consiglia di avere a File RootMakepp e per caricare esplicitamente tutto
altri che modificano o usano la variabile con "load-makefile".

GLIBLIBS globale ;= $(shell pkg-config --libs glib-2.0)

Nota anche che un giorno il tuo progetto potrebbe essere costruito insieme ad altri progetti. Per questo
motivo si consiglia di rendere sempre il nome del progetto parte di qualsiasi nome di variabile globale.

Specifico per l'obiettivo assegnazioni

obiettivo: VARIABILE = stringa
obiettivo: VARIABILE := stringa
obiettivo: sovrascrivere VARIABILE += stringa

Imposta un valore specifico della destinazione della variabile. È attivo un valore specifico per il target esclusivamente
in un'azione che produce il bersaglio dato. Questo è usato principalmente per cose come
Questo:

FLAG := -O2

mio_prog: file1.o file2.o file_speciale.o

file_speciale.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(ingresso) -o $(uscita)

Quello che succede qui è che tutti i file ".c" verranno compilati con l'ottimizzazione ("-O2") con l’esclusione di
"special_file.c", che viene compilato in modalità debug ("-g"). Questo è un modo conveniente per
specificare diverse opzioni di compilazione solo per pochi file.

Le assegnazioni di variabili specifiche della destinazione come questa si applicano solo alle azioni della regola; essi
non sono in vigore quando si valutano le destinazioni o le dipendenze di una regola. Se una regola
ha più di un obiettivo, le assegnazioni di variabili specifiche per l'obiettivo sono prese solo dal
prima di tutto obbiettivo. Nota anche che le variabili specifiche del target di makepp sono leggermente diverse
da GNU make's in quanto si applicano solo alla regola per il file menzionato e non a
nessuno dei suoi predecessori.

L'espansione con caratteri jolly viene eseguita sul bersaglio, quindi puoi fare qualcosa del genere:

test_*.o : CFLAGS += -TEST

Per compatibilità con GNU make, "%" può essere usato al posto di "*".

Variabile Sostituzione
Le regole di sostituzione delle variabili di Makepp sono simili a quelle di altre marche, ma in qualche modo
più potente. Come in tutte le marche, "$(CC)" o "${CC}" rappresentano entrambi il valore del
variabile CC. Se hai bisogno di un simbolo letterale del dollaro, inserisci un doppio simbolo del dollaro ($$), come
Questo:

obiettivo: dip1 dip2 dip3 dip4
&rm -f $(uscita)
per file in $(input); do cat $$file >> $(output); fatto

Inoltre makepp ha una sintassi "$[VARIABLE]", che fa la stessa cosa dell'altra
due, ma prima che makepp crei qualcos'altro. Questo permette di usarlo per regole complete
e/o condizionali:

definisci regola_staffa =
ifdef QUALCHE_VAR
parentesi:
&echo questa è una regola -o $(output)
endif
def

$[regola_parentesi]

stile rc sostituzione

Per impostazione predefinita, makepp usa la sostituzione in stile rc (così chiamata perché è stata introdotta da
guscio rc). Questo è meglio illustrato da un esempio:

MODULI = abcd

mylib.a : module_dir/$(MODULI).o $(ALTRI_OGGETTI)
$(CXX) $(dipendenze) -o $(destinazione)

Il prefisso "module_dir/" è anteposto a ciascuna parola in MODULES e il suffisso ".o" è
allegato ad ogni parola.

Puoi anche usare la sostituzione in stile rc senza nemmeno mettere l'elenco di parole in a
variabile; la sintassi è "$(parola1 parola2)". Nota lo spazio tra la parentesi e il
prima parola. Quindi l'esempio precedente avrebbe potuto essere scritto come:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dipendenze) -o $(destinazione)

Una variabile fornirà una sostituzione in stile rc solo quando contiene più di una parola.
Con una parola è come fare tradizionale. Ahimè, quando la variabile è vuota, c'è un
conflitto. Il tradizionale fa semplicemente espanderlo alla stringa vuota. Ma quando pensi a
come lista, vorresti che "-I$(DIRLIST)" scomparisse, non dare un "-I" solitario. Il
la soluzione è avvolgerlo in un elenco che inizia con uno spazio: "-I$( $(DIRLIST))" ti dà
esattamente tante opzioni quante sono le parole nell'elenco.

Se metti più variabili nella stessa parola che si espandono in matrici di parole, rc-style
la sostituzione prende effettivamente il prodotto cartesiano, quindi puoi fare qualcosa del genere se
tu vuoi:

DIRS = s1 s2
MODULI = abc
SUFFISSI = .o .c
FILE := $(DIRS)/$(MODULI)$(SUFFISSI)

e FILES conterranno la stringa

s1/ao s1/ac s1/bo s1/bc s1/co s1/cc s2/ao s2/ac s2/bo s2/bc s2/co s2/cc

Oltre allo spazio bianco, la sostituzione in stile rc si ferma a qualsiasi citazione, rotonda, riccia o quadrata
parentesi e qualsiasi tra ", : ; = # @". Nota che questo può essere sorprendente, e di nuovo necessario
un elenco esplicito. Supponi di voler cercare le intestazioni per carattere jolly in tutte le directory
iniziando con una lettera maiuscola:

ERRATO := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
BUONO := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Se la sostituzione in stile rc si intromette, o se hai bisogno di avere l'inizio o il finale
spazi bianchi nelle variabili make, quindi puoi disattivare la sostituzione in stile rc impostando
la variabile "makepp_simple_concatenation=1". Puoi disattivarlo globalmente sul comando
riga o come variabile di ambiente. Oppure in base al makefile impostando la variabile in
il tuo makefile. Dovresti farlo vicino alla parte superiore del makefile, altrimenti potresti imbatterti in
situazioni divertenti in cui viene utilizzata la sostituzione in stile rc per alcune valutazioni e non per altre.
(Tutte le espressioni valutate prima dell'assegnazione utilizzeranno sostituzioni in stile rc e all
le espressioni valutate dopo non lo faranno. Dal momento della valutazione delle espressioni in
makefiles è complicato e non sempre ovvio dall'ordine delle istruzioni nel
makefile, è meglio impostare "makepp_simple_concatenation" il prima possibile.) Puoi
anche impostalo solo per un obiettivo:

obiettivo: makepp_simple_concatenation = 1
bersaglio:
&echo before_first$(LIST)after_last -o $(output)

Poiché "$[VARIABLE]" viene valutato prima di "$(VARIABLE)", combinando i due in rc-
la sostituzione non darà il risultato che potresti aspettarti, a meno che non lo avvolga in un'esplicita
elenco:

A = ab
N = 1
CATTIVO := $(A)$[N]
BUONO := $(A)$( $[N])

Le ultime righe vengono lette come

CATTIVO := $(A)1 2 # a1 b1 2
BUONO := $(A)$( 1 2) # a1 a2 b1 b2

Sostituzione Riferimenti

Un riferimento di sostituzione ha la forma "$(VAR:A=B)", dove A è un modello da trovare e B è
un modello con cui sostituirlo. I riferimenti di sostituzione sono l'abbreviazione di
funzione "patsubst". Per esempio:

source_files = ac bc cc dc
file_oggetto = $(file_sorgente:%.c=%.o)

imposterà "$(object_files)" su "ao bo co do". Il "%" è un carattere speciale corrisponde
qualsiasi stringa arbitraria. Se sia A che B iniziano con "%", un caso comune durante la sostituzione
suffissi, possono essere omessi:

file_oggetto = $(file_sorgente:.c=.o)
object_files = $(source_files:c=o) # stesso, perché . non è speciale

spazio bianco in variabili

Se hai bisogno di controllare lo spazio bianco in una variabile, devi (attualmente) disabilitare rc-style
sostituzione (impostando "makepp_simple_concatenation=1") e quindi utilizzare una sintassi come questa:

nullo =
T = -o $(nullo)

oppure, con valutazione vuota:

T = -o$()

Quando lo fai, la variabile "T" contiene "-o" seguito da uno spazio.

Questo tipo di tecnica per gestire gli spazi bianchi non è raccomandato. Se hai bisogno di variabili
nel tuo makefile per contenere spazi, dovresti pensare seriamente a quello che stai facendo.
Se hai bisogno di gestire gli spazi, di solito è molto meglio inserire il codice Perl nel tuo
makefile per occuparsene (usando le istruzioni "perl_begin" o "sub") o per gestirlo
nelle istruzioni di shell nelle azioni delle regole.

Questi casi in genere si verificano quando le persone tentano di utilizzare le stesse regole per diversi
architetture che non utilizzano la tipica sintassi dei comandi Unix. Ad esempio, a volte si vede
cose del genere nei makefile:

ifeq ($(ARCH),arco bizzarro)
O := /USCITA=
altro
nullo :=
O := -o $(nullo)
endif

%.o: %.c
$(COMPILER) $(ingresso) $(O)$(uscita)

Puoi farlo con makepp se lo desideri davvero, ma probabilmente scoprirai che il tuo
i makefile sono sostanzialmente più leggibili se hai una variabile meno complicata
sostituzione, ad es.

ifeq ($(ARCH),arco bizzarro)
%.o: %.c
$(WEIRD_COMPILER) $(ingresso) /OUTPUT=$(uscita)
altro
%.o: %.c
$(CC) -c $(ingresso) -o $(uscita)
endif

Gli spazi bianchi non sono mai consentiti nei nomi delle variabili, solo nei loro valori. Questo è diverso
da alcune implementazioni.

Automatico Variabili
Le variabili automatiche sono variabili che assumono valori diversi a seconda di quale regola
in cui vengono valutati. Makepp supporta la maggior parte delle variabili automatiche che altri
versioni di fare uso. Inoltre, ha nomi meno criptici e più lunghi per la maggior parte di loro
che puoi usare invece. (Per i makefile legacy che ridefiniscono questi nomi, il
definizione nel makefile sovrascrive il significato predefinito. Ad esempio, se dici
"target = abc" nel tuo makefile, quindi "$(target)" si espanderà sempre in "abc" e non
essere più equivalente a $@.)

Di seguito è riportato un elenco completo di tutte le variabili automatiche supportate da makepp:

produzione
bersaglio
$@ La destinazione della regola corrente. In realtà, poiché makepp supporta più target per
qualsiasi regola, questa è la prima di tutto obbiettivo. Ad esempio, nella seguente regola

y.tab.c y.tab.h : parser.y
$(YACC) -o $(uscita) $(YFLAGS) $(ingresso)

"$(output)" conterrà il valore y.tab.c. Poiché queste variabili magiche sono in effetti
funzioni, puoi anche passare un indice come argomento. Questo conta da 1 o indietro
da -1. Quindi "$(output 2)" o "$(output -1)" conterrà il valore y.tab.h.

Sebbene tutte e tre le forme di questa variabile abbiano lo stesso valore, c'è una differenza in
interpretazione per regole multitarget. Se usi il nome criptico vecchio stile $@,
makepp lo interpreterà come un set di regole vecchio stile, piuttosto che come una regola moderna che
produce tutti quei bersagli in una volta sola:

ab: # davvero: una regola ciascuno per a e b
tocca $@

cd: # errore: mpp si lamenta che questo non ha compilato d
tocca $(uscita)

uscite
obiettivi
Tutti i bersagli della regola attuale. Uguale a "$(target)" a meno che non ce ne sia più di uno
obbiettivo. Nell'esempio sopra, "$(output)" sarà y.tab.c y.tab.h. Puoi passare un
indice, quindi "$(output 2 1)" sarà y.tab.h y.tab.c.

dipendenza
ingresso
$< La prima dipendenza esplicita della regola. Ad esempio, in questa regola

%.o: %.c
$(CC) $(CFLAGS) -c $(ingresso) -o $(uscita)

"$(input)" sarà il nome del .c file, indipendentemente da cosa .h file makepp
scopre. Se specifichi più di una dipendenza, puoi ottenerle passando un
index: "$(input $(INDEX))" è la dipendenza INDEXth.

dipendenze
Ingressi
$^ Tutte le dipendenze esplicite del target, escluse .h file scoperti da
makepp_scanning per include.

Ad esempio, nella regola

mioprog.o : *.o
$(CC) $(CFLAGS) $(input) -o $(output)

"$(inputs)" saranno tutti i file .o nella directory. Puoi scegliere solo quelli che
desidera passando un elenco di indici. Se specifichi esplicitamente diversi tipi di file,
puoi sceglierli come in "$(input 2 3 4)" (ma con un carattere jolly non lo è troppo
promettente).

dipendenze_ordinate
input_ordinati
$+ Tutte le dipendenze del target, in ordine ordinato, con i duplicati rimossi.
Equivalente a "$(sort $(input))".

change_dipendenze
input_modificati
$? Le dipendenze della destinazione che sono cambiate. Questo include solo esplicito
dipendenze (cioè quelle che elenchi nel makefile), non scoperte implicitamente
dipendenze dalla scansione (come i file .h).

Questo è comunemente usato in comandi come questo:

libmine.a : $(MODULI): build_check ignore_action
$(AR) con $@ $?

vale a dire, ar viene detto di sostituire solo quei moduli che sono cambiati. (Notare la
regola di controllo build "ignore_action". Se non lo specifichi, makepp forzerà il
azione da eseguire ogni volta che cambia. Se nessuna dipendenza è cambiata, il
la stringa di azione sarà "ar ru libmine.a" che è probabilmente diversa da quella che era
l'ultima volta che l'hai eseguito, quindi senza "ignore_action" makepp lo eseguirà. In questo
caso, è innocuo, ma con altri comandi potrebbe essere un problema. Vedere
makepp_build_check per i dettagli su "ignore_action".)

Costruire archivi come questo non è una buona idea perché ridurrà le tue build
affidabile. Il problema è che se crei l'archivio, ne rimuovi uno
i moduli dalla lista dei MODULI, i moduli saranno ancora nell'archivio e
makepp

stelo
$* La radice in una regola del modello (cioè, qualunque sia la corrispondenza di '%'). In alternativa, se questo
non è una regola del modello, restituisce il nome del file senza l'estensione (cioè è
equivalente a "$(nomebase $(input))".

Questo è principalmente per la compatibilità con le versioni precedenti. Ad esempio, nelle vecchie versioni di make the
unico modo per dirgli come compilarne uno .c file nel corrispondente .o il file era come
Questo:

.co:
$(CC) $(CFLAGS) -c $*.c -o $*.o

Questo è un pessimo modo di scrivere la regola. È molto più chiaro usare lo stile GNU-make
regole del modello, in questo modo:

%.o: %.c
$(CC) $(CFLAGS) -c $(ingresso) -o $(uscita)

foreach
Il nome del file corrente dalla clausola "foreach". le clausole "foreach" sono usate raramente,
ma sono il tipo di regola modello più generico supportato da makepp. Per
esempio,

#
# Crea file .c con una sorta di preprocessore speciale:
#
%.c: %.k
$(preprocessore) $(input) > $(output)

#
# Compila i file .c in file .o:
#
%.o: %.c
$(CC) $(CFLAGS) -c $(ingresso) -o $(uscita)

#
# Speciali flag alternativi di compilazione per i file .c che sono derivati
# da file .k:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(ingresso) -o $(uscita)

Vedere la documentazione sulla clausola foreach nelle regole per maggiori dettagli ed esempi.

$/ Questa è essenzialmente una costante, "/" o su Windows nativo "\". Ne hai bisogno, se
vuoi avviare un programma in modo portabile, ad esempio uno che hai creato nella directory corrente:

miooutput:
.$/mioprog >$(output)

Per i nomi di file passati come argomenti non è così necessario in quanto Windows può gestire Unix
sintassi lì.

Opzione Variabili
Puoi impostarli in tutti i modi spiegati sopra (tranne se diversamente indicato) per modificare
il comportamento di makepp. Per impostazione predefinita sono tutti indefiniti.

MAKEPP_DEBUG
Se esporti questo con un valore vero prima di chiamare makepp, ottieni più debug
Informazioni. Questa è la "RULE_SOURCE" dei file creati mentre è in vigore sotto
makeppinfo, mppi e dettagli sull'espansione delle variabili e sulla corrispondenza delle regole sotto
makepplog, mppl. Questo ti mostrerà anche se makepp esaurisce la memoria o si blocca,
perché espande all'infinito le stesse variabili:

A = $A # valutazione differita, bisogno :=
B = $C
C = $B

MAKEPP_LN_CP
Vedere la nota in &ln.

makepp_percent_subdir
Imposta questo su un valore vero (come 1) per avere "%" nelle destinazioni o nelle dipendenze corrispondenti
su più di una directory.

makepp_require_phony
Imposta questo su un valore vero (come 1) per prevenire la falsità implicita (cioè se una regola
riesce senza produrre il suo obiettivo). Questa variabile dovrebbe essere vera per impostazione predefinita, per
prevenire catene di dipendenze interrotte, ma ciò infrangerebbe la retrocompatibilità con
makefile sciatti.

makepp_signature_C_flat
Questa è un'opzione per la firma C. Impostalo su un valore vero (come 1) per trattare il tuo
sorgenti come appiattite, cioè tutte le nuove righe (tranne intorno alle dichiarazioni del preprocessore) sono
trattati come spazi bianchi e le direttive "#line" vengono ignorate.

makepp_simple_concatenazione
Impostalo su un valore vero (come 1) per prevenire la "sostituzione in stile rc".

PERL
Puoi impostarlo sull'esatto perl che stai usando per eseguire gli script in makepp
suite ed esportarlo. Questo può aiutare a eseguire sub-script con lo stesso perl. Questo è
principalmente utile per la suite di test, l'installazione e per le build ricorsive.

VPATH
L'impostazione di questa variabile su un valore chiama implicitamente "vpath % value".

predefiniti Variabili
Makepp predefinisce alcune variabili, che puoi sovrascrivere:

AR Predefinito: "ar".

ARFLAG
Predefinito: "rv".

AS Predefinito: "come".

CC Predefinito: Il primo trovato tra "gcc", "egcc", "pgcc", "c89" o "cc", o su Windows
inoltre "cl" o "bcc32".

FLAG
Predefinito: Se "$(CC)" è un compilatore GNU "-g -Wall", se è uno dei due Windows
compilatori niente, altrimenti "-g".

CURDIR
La directory in cui risiede il Makefile corrente.

CXX Predefinito: Il primo trovato tra "g++", "c++", "pg++", "cxx", "C""C" o "aCC", o su
Windows inoltre "cl" o "bcc32".

CXXFLAG
Predefinito: Se "$(CXX)" è un compilatore GNU "-g -Wall", se è uno dei due Windows
compilatori niente, altrimenti "-g".

F77 Predefinito: Il primo trovato tra "f77", "g77" o "fort77".

FC Predefinito: "$(F77)".

LD Predefinito: "ld".

LEX Predefinito: Il primo trovato tra "lex" o "flex".

LIBTOOL
Predefinito: "libtool".

FARE
Questa variabile ha due valori diversi, a seconda della presenza o meno di
"--tradizionale-ricorsivo-make". Makepp riconosce quando viene utilizzata questa variabile e
disattiva alcune funzionalità, anche prima che la ricorsione abbia effettivamente luogo. Questo può essere
indesiderabile mentre lo stai gradualmente eliminando, quindi prima converti le chiamate in a
makepp specifico "$((MAKE))", che non disattiverà le funzionalità. Non dovresti impostarlo
perché questo interrompe il nostro lavoro di ricorsione intelligente.

FARECMDGOALS
Questa variabile è impostata ma non utilizzata da makepp. Puoi interrogarlo per fare qualcosa solo se
è stato richiesto un determinato obiettivo.

Predefinito: Qualunque sia il target esplicito fornito dall'utente (o un'invocazione ricorsiva).
Vuoto quando si costruisce implicitamente il target predefinito.

ifneq $(filtro destinazione speciale, $(MAKECMDGOALS))
# special-target è uno degli attuali target espliciti
altrimenti ifeq $(MAKECMDGOALS)
# nessun target esplicito
endif

MAKEFLAGS (esportati)
Le opzioni standard con cui è stato chiamato makepp. Quelli che hanno una sola lettera
sono combinati all'inizio senza un "-" iniziale (il cielo sa perché gmake ha scelto
per eliminare il "-").

FAI INFORMAZIONI
Predefinito: "makeinfo".

MAKEPPFLAGS (esportato)
Questo è impostato allo stesso valore di MAKEFLAGS, ma solo se questa variabile è presente in
l'ambiente di makepp.

_MAKEPPFLAGS (esportato)
Le opzioni specifiche di makepp necessarie per la compatibilità POSIX/gmake, con le quali makepp
è stato chiamato. Questi sono in una variabile separata, quindi un makefile legacy non può rompersi
compatibilità disattivando MAKEFLAGS. Questo è impostato solo con
"--tradizionale-ricorsivo-make".

MAKEPP_VERSIONE
La versione di makepp con cui stai eseguendo. Se è una versione beta, avrà un
trattino seguito da AAMMGG più altri dati interni. Puoi usarlo per "ifdef"
per nascondere costrutti specifici di makepp da altre marche.

Predefinito: Lo stesso valore visualizzato da "makepp --version"

PWD Un alias per "CURDIR".

RM Predefinito: "rm-f". Questo è pensato per i Makefile legacy. Per quelli nuovi preferibilmente usare
direttamente il comando integrato &rm. Se vuoi scrivere una falsa regola pulita, guarda
invece il comando "makeppclean -r".

ROOT
Il percorso relativo alla radice del tuo sistema di compilazione, cioè la directory più in alto in
che hai un "RootMakeppfile(.mk)". Se non ne hai uno, questa variabile è
vuoto.

SHELL
Questa variabile viene rispettata solo se la "esporti". In quel caso è la Shell
cheèusato per eseguire azioni non incorporate con qualche carattere speciale in esso (semplice
quelli che vengono eseguiti direttamente). Su Windows Strawberry o ActiveState Perl, se hai
una Shell simile a Unix, devi invece impostare la tua variabile SHELL su un valore che termina con "sh"
o "sh.exe" prima chiamando makepp.

Predefinito: Il primo trovato tra "/usr/xpg4/bin/sh" (es. Solaris) o "/sbin/xpg4/sh"
(ad es. Reliant Unix) o "/bin/sh".

YACC
Predefinito: Il primo trovato tra "bison -y" o "yacc".

Variabili ed Perl
I valori delle variabili sono memorizzati come normali scalari Perl, quindi puoi accedervi direttamente da
codice Perl se hai bisogno di fare manipolazioni complicate con loro; vedi makepp_extending
per i dettagli.

L'accesso alle variabili globali da Perl si ottiene anteponendole al prefisso "Mpp::global"
pacchetto. Infatti qualsiasi variabile, non ancora presente nel makefile corrente, e che tu
assegnare a in questo pacchetto sarà da quel momento in poi globale, come se avessi appena emesso il
dichiarazione "globale" per questo.

Questo accesso diretto è tuttavia soggetto a errori! L'utente potrebbe aver sovrascritto queste variabili
sulla riga di comando o attraverso l'ambiente. Qualche altro makefile caricato prima di questo
si può aver reso la variabile globale o specifica del target. In questi casi non lo faresti
trovare il valore della variabile, o durante l'assegnazione, potrebbe toglierne la proprietà
(equivalente a un modificatore "override", ad eccezione delle specifiche del bersaglio.)

Con l'accesso diretto si aggira anche l'espansione di queste variabili, se sono di tipo
"=" o ";=". Le variabili speciali come "$(CC)" iniziano come funzioni, finché non lo sono
assegnato a. Quindi in molti casi non vedrai il loro valore.

Per questi motivi è meglio lasciare che makepp determini il valore corretto. Puoi usare il
variante "makeperl", in cui la variabile è stata valutata prima che venga ottenuto il codice Perl
interpretato:

makeperl { $$valore_corrente = '$(MAKEFILE_VAR)' }

Se hai bisogno di una variabile nei blocchi perl makefile questo si ottiene tramite la variabile Perl
$makefile come segue:

perl { $valore_corrente = $makefile->expand_variable( 'MAKE_VAR' ) }

Le funzioni ottengono sempre l'oggetto makefile passato come secondo argomento $_[1]:

sub f_f { $current_value = $_[1]->expand_variable( 'MAKE_VAR' ) }

I comandi dovrebbero essere chiamati all'interno di un'azione regola, dove è l'oggetto makefile
accessibile tramite "$Mpp::Subs::rule->{MAKEFILE}":

sub c_cmd { $valore_corrente = $Mpp::Subs::rule->{MAKEFILE}->expand_variable( 'MAKE_VAR' ) }

Usa makepp_variables online utilizzando i servizi onworks.net