makepp_functions - Online nel cloud

PROGRAMMA:

NOME

makepp_functions -- Funzioni in makepp

DESCRIZIONE

A: nome_file_assoluto,
nome_file_assoluto_nolink,
aspatico,
addprefisso,
addiffisso,
e, B: nome di base, C: chiamata, D: dire,
dir_noslash, E: errore, F: filesubst,
filtro,
filtrare,
filter_out_dir,
trova file,
trova_primo_verso l'alto,
trova_programma,
trova stringa,
trova_verso l'alto,
primo_disponibile,
prima parola,
per ciascuno, I: Se,
se è vero,
dedurre_linker,
infer_oggetti,
Informazioni, J: aderire, M: rendere,
mappa di trucco,
trucco,
carta geografica,
"mktemp", N: non dir, O: solo_generato,
solo_non obiettivi,
solo_bersagli_fonici,
solo_stantio,
solo_bersagli,
o,
origine, P: patsubst,
perla,
falso,
precompilare,
Stampa, R: percorso reale,
nomefile_relativo,
relativo a, S: conchiglia,
ordinare,
striscia,
sost,
suffisso, T: temporaneo, W: avvertimento,
carta jolly,
parola,
lista di parole,
parole, X: xargs

Qualsiasi espressione del formato "$(nome)", dove "nome" non è il nome di una variabile, oppure
"$(nome arg1 arg2 arg3)" viene interpretato come una chiamata di funzione. Il nome può contenere lettere,
trattini bassi o trattini; per evitare confusione, puoi usare trattini o caratteri di sottolineatura
in modo intercambiabile, poiché internamente i trattini vengono convertiti in caratteri di sottolineatura. Valutare tale
un'espressione richiama semplicemente una subroutine Perl. Se "nome" è preceduto da "&" esegue il
comando o script integrato con quel nome all'interno del processo makepp e restituisce lo standard
produzione. Ciò richiede che perl sia compilato per PerlIO. Se il nome non nomina una funzione
si trasforma in invocazione di chiamata.

Come con le variabili puoi scegliere tra "$(nome ...)" o "${nome ...}". Se lo desidera
inserire la stessa parentesi, deve essere abbinata, l'altra non importa: "$(name
...(){..." o "${name ...{}(...}". (Tuttavia per map e perl la prima parentesi chiusa termina
l'espressione.) Il raddoppio consente agli argomenti di estendersi su più righe. Le nuove righe sono
quindi trattati come spazi, tranne forse in "define". C'è anche la sintassi "$[name ...]"
o $[[name ...]], che viene valutato durante la lettura del makefile, prima di modificare le regole
e altri costrutti.

Makepp ha una serie di funzioni integrate che possono essere utili. Supporta quasi tutti
Le funzioni testuali di GNU make (vedi la documentazione di GNU make per i dettagli) e alcune delle sue
possedere. Puoi definire le subroutine Perl per fare quello che vuoi. Vedi la dichiarazione "sub"
e la sezione sull'estensione di makepp per maggiori dettagli.

Condizionale funzioni
ed condizione1[,condizione2[,condizione3...]]
La funzione e fornisce un'operazione AND di "cortocircuito". Ogni argomento è
ampliato, in ordine. Se un argomento si espande in una stringa vuota, l'elaborazione si interrompe e
il risultato dell'espansione è la stringa vuota. Se tutti gli argomenti si espandono in un non-
stringa vuota quindi il risultato dell'espansione è l'espansione dell'ultimo argomento.

if stringa, risultato-se-stringa-non-vuota[, risultato-se-stringa-vuoto]
se è vero stringa, risultato-se-stringa-vero[, risultato-se-stringa-falso]
Un'alternativa alle dichiarazioni "ifeq", ecc. Se la stringa non è vuota (cioè, il
condizione è vera), viene restituito il secondo argomento (la clausola "then") (dopo
espansione variabile); se la stringa è vuota, il terzo argomento (la clausola "else") è
restituito.

Per esempio,

CFLAGS := $(if $(filtro gcc egcc, $(CC)), -g -Wall, -g)

definisce CFLAGS come "-g -Wall" se la variabile CC è "gcc" o "egcc" e "-g"
altrimenti. (Questo è ciò che fanno le regole di compilazione predefinite.)

"iftrue" è simile a "if", tranne per il fatto che la stringa 0 viene trattata come vuota.

or condizione1[,condizione2[,condizione3...]]
La funzione o fornisce un'operazione OR di "cortocircuito". Ogni argomento è ampliato,
In ordine. Se un argomento si espande in una stringa non vuota, l'elaborazione si interrompe e il
risultato dell'espansione è quella stringa. Se, dopo che tutti gli argomenti sono stati espansi, tutti di
sono false (vuote), quindi il risultato dell'espansione è la stringa vuota.

Compila il ed Nome del file funzioni
nomefile_assoluto file
abspatico file
Converte i nomi di file relativi in ​​assoluti senza . or ... Per esempio,
"$(absolute_filename xyz.c)" potrebbe restituire "/usr/src/our_project/subdir/xyz.c".

nome_file_assoluto_nolink file
percorso reale file
Come nomefile_assoluto, ma assicura che i collegamenti simbolici vengano risolti.

nome di base i nomi dei file
Il nome di base è l'intero nome del file (con la directory), meno il testo dopo e
compreso l'ultimo periodo. Ad esempio, "$(nomebase miofile/versione-1.0-module.c)" è
"miofile/versione-1.0-modulo"

dir i nomi dei file
Estrae la parte della directory di ogni file nell'elenco dei nomi di file, incluso il finale
barra. Restituisce "./" se non è presente alcuna directory nel nome del file.

dir_noslash Nome del file
Uguale a "$(dir )" tranne per il fatto che non restituisce la barra finale.

filesubst modello, sostituto, parole
Eseguire una sostituzione del modello sui nomi dei file. Questo differisce da patsubst in questo
funzionerà correttamente quando vengono dati nomi alternativi per le directory (purché
precedono il segno di percentuale). Per esempio,

$(filesubst ./src/%.c, %.o, $(jolly src/*.c))

funzionerà con filesubst ma non con patsubst.

filter_out_dirs i nomi dei file
Restituisce tutti i nomi di file che non fanno riferimento a directory.

trova file nome del file, sentiero
Trova un file nel percorso specificato o nella variabile d'ambiente PATH se non c'è niente
specificato. Questo può essere utile per trovare binari o includere file. Per esempio,

TCL_INCLUDE := -I$(dir_noslash $(trovafile tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/include \
/usr/include/tcl8.4 /usr/include/tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

Questo individua il file tcl.h cercando in tutte le directory di cui sopra. L'assoluto
viene restituito il percorso del file. Quindi "$(dir_noslash )" estrae quella directory e
viene inserito nel percorso di inclusione.

trova_programma Nome
Restituisce il primo programma nell'elenco che si trova nel PATH. Questo è utile
quando ci sono più programmi equivalenti che possono essere usati e vuoi solo farlo
scegline uno. Ad esempio, ecco la definizione predefinita di diversi comuni
variabili che makepp fornisce se non ne inserisci una nel tuo makefile:

CC = $(find_program gcc egcc pgcc c89 cc) # e altro, a seconda della macchina
F77 = $(trova_programma f77 g77 fort77)
CXX = $(trova_programma g++ c++ pg++ cxx CC aCC)

Se nessuno dei programmi viene trovato, "$(find_program )" restituisce la stringa non trovata e
registra ciò che non è stato trovato. Questo di solito non si tradurrà in un makefile funzionale, ma
tenderà a generare messaggi di errore migliori. Ad esempio, se fai qualcosa del tipo
Questo:

%.o: %.c
$(CC) $(ingressi) -o $(uscite)

e makepp non riesce a trovare un compilatore C nell'elenco sopra, sostituirà non trovato.
Altrimenti la shell tenterà di eseguire il file sorgente e l'errore risultante
messaggio potrebbe essere davvero strano.

trova_in alto Nome del file
Cerca un file con il nome specificato nella directory ., .., ../ ..../../.., Ecc,
finché non viene trovato il file o non viene raggiunta la directory principale o non viene individuata la directory
su un file system diverso. (Quest'ultimo requisito serve a prevenire problemi con
automount o filesystem di rete bloccati.) Se si dispone di un File RootMakepp, questo è anche
una barriera che impedisce di cercare più in alto.

Ad esempio, se hai un progetto con molti livelli di sottodirectory, potresti
includi questo frammento comune in tutti i makefile (ad esempio, usando il comando "include"
dichiarazione):

TOP_LEVEL_INCLUDE_DIR := $(find_upwards include)
# Cerca una directory che contenga il
# include la sottodirectory.

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

Un altro problema che "find_upwards" può aiutare a risolvere è localizzare la directory di primo livello
di una costruzione. Spesso è utile definire una variabile come questa:

IN ALTO := ../../..

se hai alcune informazioni importanti che si trovano solo nella directory di primo livello. Ma
questo è difficile da mantenere, perché il numero di ".." è diverso per i diversi livelli
dell'albero delle directory. Invece, puoi usare "find_upwards" per individuare un file che è
noto per essere presente solo nella directory di primo livello. Supponiamo, ad esempio, che il
il file "LICENSE" si trova solo nella directory di livello superiore. Quindi potresti fare questo:

TOP := $(dir_noslash $(find_upwards LICENZA))

"$(find_upwards LICENSE)" restituisce il percorso completo del file di licenza;
"$(dir_noslash ...)" elimina il nome del file, restituendo solo la directory.

(Si noti che l'istruzione "include" cerca automaticamente i file verso l'alto, quindi
non c'è bisogno di fare qualcosa del genere:

includi $(find_upwards top_level_rules.mk)

Invece, puoi semplicemente fare

includi top_level_rules.mk

e funzionerà altrettanto bene.)

Se il file non viene trovato, "find_upwards" interromperà la compilazione con un messaggio di errore.

Se specifichi più di un file, find_upwards cercherà il primo, quindi
la seconda e così via. In altre parole,

$(trova_verso l'alto file1 file2)

è equivalente

$(trova_file in alto1) $(trova_file in alto2)

Se vuoi cercare uno qualsiasi dei file, usa invece "find_first_upwards".

trova_prima_in alto file1 file2 ...
Questa funzione si comporta come "find_upwards" tranne per il fatto che restituisce il primo file di any
file nell'elenco che trova. In particolare, controlla la directory corrente per
uno dei file nell'elenco e restituisce il primo file esistente o che può essere creato.
Se nessuno dei file esiste o può essere creato in quella directory, controlla .., poi
../ .., ecc., finché non raggiunge la directory radice o una directory che sia
situato su un file system diverso.

primo_disponibile file1 file2 ...
Restituisce il primo file in un elenco esistente o che può essere creato. Questo può essere utile per
adattare i tuoi makefile per lavorare su diverse macchine o reti, dove
i file importanti possono trovarsi in posti diversi. Ad esempio, ecco una riga da
uno dei miei makefile:

TCL_LIB = $(primo_disponibile \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

Questa riga controllerà la libreria Tcl in tutti i punti sopra, fermandosi a
il primo che trova. Il comando link include quindi $(TCL_LIB) quindi otteniamo il
libreria Tcl appropriata.

infer_linker file1 file2 ...
Dato un elenco di file oggetto, prima creali se non lo sono ancora. poi trova
se dipendono da una sorgente Fortran, C++ o C e restituiscono il corrispondente
compilatore (che sa come collegare meglio di "ld").

infer_oggetti file1 file2 ..., modello
$(infer_objects oggetto1.o oggetto2.o, *.o)

Se usi convenzioni standard per quanto riguarda i nomi dei file di intestazione, makepp è in grado di
indovinare quali file ".o" o ".lo" devono essere collegati al tuo programma. io uso questo per
scegli i file da una directory della libreria che contiene moduli usati in molti modi diversi
programmi. Invece di creare un file di libreria ".a" e fare in modo che il linker scelga il
moduli pertinenti, makepp può scegliere i moduli pertinenti per te. In questo modo, solo
i relativi moduli vengono compilati.

L'algoritmo di Makepp per inferire le dipendenze degli oggetti dipende dalla convenzione che
l'implementazione di tutte le classi o funzioni definite in un file di intestazione "xyz.h" sono
compilato in un file oggetto chiamato "xyz.o" (o "xyz.lo"). Quindi l'algoritmo di makepp per
l'inferenza delle dipendenze degli oggetti inizia con uno o pochi oggetti che sappiamo devono essere
collegato al programma. Guarda quali file sono stati inclusi con "#include" in
quelle fonti e cerca di trovare i file oggetto corrispondenti per ciascuno degli include
File.

"$(infer_objects )" deve essere menzionato nell'elenco delle dipendenze di un programma, come
Questo:

mioprog: $(infer_objects main.o other_object.o, \
**/*.o /altro/libreria/dirs/**/*.o)
$(CXX) $(input) -o $(output) $(LIBS)

La funzione "$(infer_objects)" accetta due argomenti (separati da una virgola, come mostrato).
Il primo è uno o alcuni file oggetto che sono noti per essere richiesti (i caratteri jolly sono
ammissibile qui). Il secondo è un elenco di possibili oggetti (normalmente useresti a
carattere jolly qui) che potrebbe essere collegato se necessario. Il valore di ritorno da questo
la funzione è una lista che contiene prima tutti gli oggetti nel primo argomento, e
poi dopo quelli, tutti gli oggetti aggiuntivi che erano contenuti nel secondo argomento
richiesti dagli oggetti nel primo argomento.

Ad esempio, supponiamo che "main.o" provenga da "main.cpp", che include "my_class.h".
"$(infer_objects)" cerca i file con il nome "my_class.o". Se esattamente uno di questi
il file viene trovato, viene aggiunto all'elenco. (Se vengono trovati due file oggetto "my_class.o"
in diverse directory, viene stampato un messaggio di avviso.) anche "infer_objects"
esamina "my_class.cpp" per vedere cosa include e quali sono i file oggetto aggiuntivi
implicito.

mktemp
mktemp prefisso
mktemp prefissoXXX
mktemp /
Restituisce un nome di file temporaneo imprevedibile, che attualmente non esiste. Senza nome
che punta allo stesso file viene restituito due volte, anche con percorsi relativi diversi,
all'interno di un'esecuzione di makepp (tranne forse con make ricorsivo tradizionale, o se Perl
il codice in esecuzione all'interno di un'azione della regola chiama "f_mktemp"). Alla fine del makepp corri tutto
i file restituiti da questa funzione vengono eliminati, se esistono (di nuovo tranne quelli
restituito da questa funzione nel codice Perl in esecuzione all'interno di una regola).

Qualsiasi numero di "X" maiuscole alla fine dell'argomento viene sostituito da altrettanti
lettere e cifre casuali. Più ce ne sono, meno è probabile che si scontrino
con altri processi, quindi se dai un prefisso come "/tmp/abc.", dovresti averne abbastanza
"X". Se è presente più di una X, il primo carattere deriva dall'ID processo. Se
non ce ne sono, è come se ce ne fossero dieci, il che dovrebbe bastare (8.4e17
possibilità o 3.7e15 su Windows). Se non ci sono argomenti, il prefisso predefinito è
"tmp." nella directory corrente.

Nota che non vuoi dare un nome come obiettivi e dipendenze delle regole. Il
il risultato sarebbe corretto, ma verrebbe ricreato ogni volta che esegui makepp.

Inoltre, poiché è sempre diverso, dovresti usarlo in un'azione regola solo se usi
":build_check ignore_action":

TMPFILE ;= $(mktemp) # 1 chiamata; "=" significherebbe 3 chiamate: 3 file
Conteggio A Conteggio B: :build_check ignore_action
produci-come-e-b >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o A-count
&grep -c /B/ $(TMPFILE) -o B-count

Oppure dovresti esportarlo e lasciare che la Shell lo valuti:

esporta TMPFILE ;= $(mktemp)
Conteggio A Conteggio B:
produ-As-and-Bs >$$TMPFILE # makepp non vede il valore var
fgrep -c A $$TMPFILE >A-count
fgrep -c B $$TMPFILE >B-count

L'ultimo modulo ripete il valore restituito precedente, quindi puoi usarlo in una regola del modello:

%.x: %.y
&grep foo $(input) -o $(mktemp)
&sed bar $(mktemp /) -o $(output) # Opera sull'output di &grep

non dir i nomi dei file
Restituisce la parte non di directory dei nomi dei file, ovvero tutto dopo l'ultimo
barra se ce n'è uno, o l'intero nome del file altrimenti.

solo_generato i nomi dei file
Restituisce solo quei nomi di file nell'elenco che sono stati generati da makepp e non da allora
modificato, in base al file di informazioni sulla build.

Questa funzione è utile nelle regole di destinazione pulite (anche se ovviamente "makeppclean" è il
variante preferita):

$(falso pulito):
&rm -f $(only_generated **/*)

only_non targets i nomi dei file
Restituisce solo quei nomi di file nell'elenco che non sono obiettivi di alcuna regola (né
regole esplicite o modello). Puoi specificare un carattere jolly (vedi "$(wildcard )"
funzione per maggiori dettagli sui caratteri jolly di makepp). Questo può essere usato per generare a
target di distribuzione, ad esempio:

.FHONY: distribuzione

distribuzione:
&mkdir our_product-$(VERSION)
&cp $(filter-out %~, $(only_nontargets *)) our_product-$(VERSION)
tar cf - nostro_prodotto-$(VERSIONE) | gzip -9c > our_product-$(VERSION).tar.gz

In questo caso, "$(only_nontargets *)" restituisce tutti i file nella directory corrente
questo non è un obiettivo di qualche regola. Il "$(filter_out %~, ...)" rimuove l'editor
backup.

Simile a "only_targets" (vedi sopra), "only_nontargets" conosce solo obiettivi che
sono già stati definiti. Questo è un problema solo se lo usi per definire le variabili
con l'assegnazione ":="; se lo usi nell'elenco delle dipendenze o nel corpo di a
regola, tutte le altre regole saranno già state viste.

solo_stantio i nomi dei file
Restituisce solo quei nomi di file nell'elenco che sono stati generati da makepp e non da allora
modificati, in base al file delle informazioni di build, ma non sono più obiettivi di alcuna regola.

Questa funzione è utile per garantire che non vi siano dipendenze da tali file,
senza forzare una build pulita di tutti gli obiettivi:

$(scarico fasullo):
&rm -f $(only_stale **/*)

In realtà, è probabilmente meglio invece scrivere uno script che chiami makepp per generare
l'elenco dei file obsoleti, quindi fare in modo che lo script rimuova tutti i file elencati che
non sono attualmente sotto il controllo del codice sorgente, nel caso in cui un file generato diventi una fonte
file. Makepp non ha una funzione del genere integrata perché makepp è (e probabilmente
dovrebbe rimanere) agnostico riguardo al controllo del codice sorgente.

solo_bersagli i nomi dei file
Restituisce solo quei nomi di file nell'elenco che sono effettivamente obiettivi di alcune regole
(regole esplicite o pattern). Puoi specificare i caratteri jolly (inclusi quelli di makepp
carattere jolly speciale, "**") nei nomi dei file. (Vedi la funzione "$(carattere jolly)" per ulteriori informazioni
particolari. Questo può essere usato per un obiettivo pulito, ad esempio:

.FONO: pulito

pulito:
&rm -f $(solo_bersagli *)

Ora se digiti "makepp clean", cancellerà tutto ciò che sa come costruire. Ma
non creare un target pulito, usa invece "makeppclean"!

Un altro posto dove può essere utile è evitare di includere stantio .o file nel tuo
costruire. Ad esempio, se crei una libreria come questa:

mialib.a: *.o
&rm -f $(uscita)
$(AR) cr $(output) $(input)

e poi elimini alcuni file sorgente ma dimentichi di eliminare il corrispondente .o File,
, il .o i file saranno ancora in giro. Ciò significa che saranno ancora incorporati in
la biblioteca nonostante non siano più utili. Se modifichi il tuo
regola così:

mialib.a: $(solo_bersagli *.o)
&rm -f $(uscita)
$(AR) cr $(output) $(input)

allora questo problema non si verificherà.

Nota che questo si riferisce solo ai file che sono noti per essere obiettivi at , il tempo Tu
invocare "solo-obiettivi". Se "only_targets" appare nelle dipendenze o azioni di a
regola, allora tutti i possibili obiettivi saranno conosciuti perché le dipendenze e le azioni non lo sono
valutata fino all'esecuzione della regola. Tuttavia, se valuti prova a valutarlo
prima nel makefile con una variabile ":=" come questa:

TUTTI_OBIETTIVI := $(solo_bersagli *)

target1: dipendenza1
azioni

target2: dipendenza2
azioni

quindi "only_targets" non saprà delle regole successive.

Allo stesso modo, "only_targets" non conosce i target prodotti nei makefile che sono
caricato con make ricorsivo. (Ma non dovresti comunque usare make ricorsivo; usa
utilizzare invece l'istruzione "load_makefile" o il caricamento implicito del makefile.)

nomefile_relativo file1 file2 file3[, barra]
Restituisce il nome di quei file relativi alla directory corrente (quella la
makefile è in). Questo può anche essere usato per pulire "./" non necessario e altra spazzatura da
il sentiero:

DIR := .
SOTTODIR:= ..
FNAME := $(DIR)/../altra directory/$(SUBDIR)/file
X := $(nomefile_relativo $(FNAME))

If barra è vero (di solito 1) è garantito che i nomi dei file restituiti contengano una barra
anteponendo "./" se necessario, in modo da poterlo utilizzare come nome eseguibile senza
preoccuparsi del percorso di ricerca del comando che sovrascrive la posizione della directory.

Se il percorso va dalla directory principale, quella principale della tua directory home o
il "$(ROOT)" del tuo sistema di compilazione, o su Windows la radice di un'unità (a seconda del
ambiente, questo accade anche per /cygdrive/c or /c), un percorso assoluto sarà
restituito invece.

relativo a file1 file2 file3[, elenco]
Restituisce il nome di quei file relativi alla directory specificata. Questo è
tipicamente utile quando per qualsiasi motivo devi eseguire un comando da a
directory diversa (directory corrente predefinita):

source_backup.tar:
cd .. && tar cf $(relativo_a $(output), ..) $(relativo_a ., ..)

suffisso nomi...
Estrae il suffisso di ogni nome di file nei nomi. Se il nome del file contiene un punto,
il suffisso è tutto a partire dall'ultimo punto. Altrimenti, il suffisso è
stringa vuota. Ciò significa spesso che il risultato sarà vuoto quando i nomi non lo sono,
e se i nomi contengono più nomi di file, il risultato potrebbe contenere meno nomi di file.

Per esempio,

$(suffisso src/foo.c src-1.0/bar.c hack)

produce il risultato ".c .c".

temporaneo parole
Fai sapere a makepp che i target specificati possono essere rimossi dalla regola che genera
loro. Simile a "falso", tranne per il fatto che makepp si aspetta un file reale con quel nome
volontà può essere influenzata dalla regola. Una regola non viene eseguita se è solo temporanea
gli obiettivi sono scaduti.

jolly modello
Restituisce i nomi ordinati di tutti i file che corrispondono al modello dato che esistono, o quelli
file che non esistono ancora ma possono essere costruiti in base alle regole che makepp conosce
circa nel punto in cui valuta l'espressione. In quest'ultimo punto differisce
dai caratteri jolly di input delle regole, che si applicano anche ai file creati da regole trovate in seguito.

Makepp supporta tutti i soliti caratteri jolly della shell ("*", "?" e "[]"). Ha anche un
carattere jolly "**" che corrisponde a qualsiasi numero di directory interposte. (Questa idea era
rubato da zsh.) Ad esempio, "**/*.c" corrisponde a tutti i .c file in tutta la fonte
albero. "objects/**/*.o" corrisponde a tutti i .o file contenuti ovunque nel
sottodirectory oggetti o una delle sue sottodirectory o una delle loro sottodirectory. Il
Il carattere jolly "**" non seguirà i collegamenti software alle directory a nessun livello, né lo farà
tentare di accedere a directory che esistono ma non possono essere lette. Anche file e
le directory che esistono ma non possono essere lette non verranno restituite da "$(wildcard )".

Corda funzioni
addprefisso prefisso, parole
Antepone la stringa del prefisso a ciascuna delle parole. Questo è principalmente per GNU make
Compatibilità; usando l'espansione in stile rc, questo può essere fatto in un modo più leggibile
come questo:

MODULI := abcd
X_OLD_STYLE := $(aggiungi prefisso $(OBJDIR)/, $(aggiungi suffisso .o, $(MODULI)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # Non è più facile da leggere?

adduffix suffisso, parole
Aggiunge la stringa del suffisso a ciascuna delle parole. Questo è principalmente per GNU make
Compatibilità; usando l'espansione in stile rc, questo può essere fatto in un modo più leggibile
come questo:

X_OLD_STYLE := $(addsuffisso .o, $(MODULI))
X_NEW_STYLE := $(MODULI).o

chiamata variabile[, parole]...
La funzione "chiamata" è unica in quanto può essere utilizzata per riguardare variabile come
funzione parametrizzata. Puoi assegnare un'espressione complessa a variabile E l'uso
"call" per espandere il suo contenuto a diversi valori parametrizzati da parole più tardi. In
altri sistemi make, una variabile che viene utilizzata principalmente allo scopo di essere ampliata tramite
"chiamare", si chiama a macro.

Durante l'espansione della macro, le variabili temporanee $1, $2, "..." fare riferimento al
argomenti dati a "call" durante la sua invocazione. La variabile $0 sarà ampliato a
il nome della macro (es variabile) quella "chiamata" è attualmente in espansione.

Non c'è limite, con quanti argomenti una macro può essere "chiamata" o con quanti
parametri che una macro può aspettarsi. Se passi più argomenti a "call" come macro
bisogno, tutti gli argomenti in eccesso verranno scartati. Se passi meno argomenti di a
la macro aspetta, tutti i parametri eccedenti si comprimeranno nella stringa vuota.

Prima un semplice esempio:

resto = $(lista di parole 2, $(parole $(1)),$(1))
lista = ABCDE
butfirst := $(chiama resto,$(lista))

Qui, la variabile "$(butfirst)" conterrà l'elenco "BCDE".

E ora un esempio più complesso per mostrare ciò che è possibile:

resto = $(lista di parole 2,$(parole $(1)),${1})
miamappa = $(se $2,$(call $1,$(firstword $2)) $(call $0,$1,$(call rest,$2)))
minuscolo = ${makeperl lc("$1")}

UCWORDS = TUTTE QUESTE PAROLE SONO MAIUSCOLE
DCWORDS := $(chiama miamappa,downcase,$(UCWORDS))

Ora "$(DCWORDS)" contiene "tutte queste parole sono maiuscole". A proposito: non fa
differenza, se accediamo agli argomenti tramite $1, "${1}" or "$(1)" all'interno di una macro.

Puoi usare direttamente la variabile come se fosse una funzione, se non c'è
funzione di quel nome. Questo viene convertito internamente in "call", quindi questi sono
equivalente:

discussione = $0 si è trasformato in $1 $2.
direct = $(discussione an,argomento)
chiamato = $(chiama discussione,an,argomento)

Potrebbe sembrare discutibile se "$[call]" debba espandere anche il "$[]" della macro
espressioni, o se una funzione dovrebbe sempre fare la stessa cosa, non importa come
è chiamato. Quest'ultimo è stato scelto, perché con la normale sintassi make sarebbe
impossibile ottenere "$[1], $[2]..." in una variabile (verrebbero sostituiti da nulla,
prima ancora che l'assegnazione abbia luogo.) Quindi, se hai una macro per definire a
regola, vuoi che vengano visualizzate espressioni come "$(output)" quando la regola viene analizzata, quindi
devi proteggerli da "chiamata":

definire la mia regola
$ 2: $ 1
miocomando $$(input) -o $$(output)
fine
$[myrule mio input, mio ​​output]

filtro modelli, parole
Restituisce tutte le parole nell'elenco che corrispondono ai modelli. I modelli possono essere semplicemente altri
parole o caratteri jolly di nomi di file (ad esempio, "*", "?" e "[az]" sono riconosciuti), oppure possono
avere un carattere "%", che significa corrispondere a qualsiasi stringa in quel punto (come "*").

filtrare modelli, parole
Restituisce tutte le parole nell'elenco che non corrispondono ai modelli. I modelli possono semplicemente essere
altre parole, o i caratteri jolly dei nomi di file (ad es. vengono riconosciuti "*", "?" e "[az]"), o
possono avere un carattere "%", che significa corrispondere a qualsiasi stringa in quel punto (come
"*").

Per esempio:

libproduction.a: $(filter_out test_*, $(carattere jolly *.o))

metterò tutto .o file che esistono o possono essere compilati, eccetto quelli che iniziano con test_,
ai miglioramenti libproduzione.a.

trovastringa trova, in
Reso Find, se è una sottostringa di in.

prima parola parole
Restituisci la prima parola.

carta geografica parole, codice perl
makemap parole, codice perl
Analogamente alla mappa di Perl, si applica codice perl a turno a ogni parola e restituisce il
risultati. La prima variante è un semplice codice Perl, mentre la seconda variante passa prima
il perlcode tramite l'espansione della variabile Make-style. Le parole sono espanse in entrambi
casi.

Le parole sono in $_ e vengono restituite a meno che non si annulli $_. Questo è destinato a
modifiche non facilmente gestibili da "patsubst". Solo la prima virgola è un separatore,
tutti gli altri sono considerati parte del codice perl.

# Cambia le parole. Doppia parentesi, per consentire le parentesi in perlcode, oppure usa ${}:
X = $((mappa $(VALORI), s/(.+)-(.+)/$2-$1/))
# Puoi usare le espressioni make, ma poi devi usare $$ per Perl $:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ o $$_ = 'fallito')
# Puoi eliminare i candidati:
Y = $(mappa $(VALORI), undef $_ if /no_good/)

join parole1, words2
Fai un join a coppie delle prime parole e delle seconde parole.

patsubst modello, sostituto, parole
Esegue una sostituzione su ogni parola nell'elenco delle parole. Un carattere "%" corrisponde a qualsiasi
corda. Questo è meglio illustrato da un esempio:

OBJS = $(patsubst %.c, object_dir/%.o, $(C_SOURCES))

prende ogni file in C_SOURCES e restituisce il nome di un file oggetto in object_dir.
A volte è più conciso usare un riferimento di sostituzione, ad esempio, quanto sopra potrebbe
sono stati scritti come

OBJS = $(C_SOURCES:%.c=dir_oggetto/%.o)

sorta parola1 parola2 parola3 ...
Ordina le parole in ordine lessicale e rimuove i duplicati.

striscia stringa
Rimuove gli spazi bianchi iniziali e finali dalla stringa e sostituisce ogni interno
sequenza di uno o più caratteri di spaziatura con uno spazio singolo. Quindi, "$(striscia ab
c )" risulta in "abc".

subst da,a,testo
Esegue una sostituzione testuale sul testo del testo: viene sostituita ogni occorrenza di from
da a. Il risultato viene sostituito dalla chiamata di funzione. Per esempio,

$(subst ee,EE,piedi per strada)

sostituisce la stringa "fEEt on the strEEt".

parola n, testo
Restituisce il nla parola di testo. I legittimi valori di n inizia da 1 all'inizio
o indietro da -1 alla fine. Se n è maggiore del numero di parole in testo, le
il valore è vuoto.

lista di parole indice, parole
lista di parole primo indice, ultimo indice, parole
Nel primo modulo fornisci un elenco di indici (contando da 1 all'inizio o
indietro da -1 alla fine) per selezionare le parole desiderate. Nella seconda forma tu
specificare l'intervallo di parole che si desidera restituire.

parole testo
Restituisce il numero di parole in testo.

Miscellanea funzioni
foreach var,elenco,testo
I primi due argomenti, var ed stratagemma, vengono espansi prima di qualsiasi altra operazione; Nota
che l'ultimo argomento, il testo, non viene espanso contemporaneamente. Allora per ogni parola di
il valore espanso di list, la variabile denominata dal valore espanso di var è impostata su
quella parola e il testo viene espanso. Presumibilmente il testo contiene riferimenti a quella variabile,
quindi la sua espansione sarà ogni volta diversa.

Questo semplice esempio imposta la variabile file all'elenco di tutti i file nel
directory nell'elenco dirs:

dirs := abcd
files := $(per ogni directory,$(dirs),$(carattere jolly $(dir)/*))

Qui il testo è "$(carattere jolly $(dir)/*)". La prima ripetizione trova il valore "a" per dir,
quindi produce lo stesso risultato di "$(carattere jolly a/*)"; la seconda ripetizione produce
il risultato di "$(carattere jolly b/*)"; e il terzo, quello di "$(wildcard c/*)".

Questo esempio ha lo stesso risultato (tranne per l'impostazione di "dirs") dell'esempio seguente:

file := $(carattere jolly a/* b/* c/* d/*)

Quando il testo è complicato, puoi migliorare la leggibilità assegnandogli un nome, con un
variabile aggiuntiva:

trova_file = $(carattere jolly $(dir)/*)
dirs := abcd
files := $(per ogni directory,$(dirs),$(find_files))

Qui usiamo la variabile find_files in questo modo. Usiamo il semplice "=" per definire a
variabile in espansione ricorsiva, in modo che il suo valore contenga una chiamata di funzione effettiva a
essere riespanso sotto il controllo di foreach; una variabile semplicemente espansa non andrebbe bene,
poiché il carattere jolly verrebbe chiamato solo una volta al momento della definizione di find_files.

Nota: non confondere questo con la variabile speciale "$(foreach)".

info testo
identificazione dei warning testo
errore testo
Testo di output che restituisce il nulla. Il primo va a STDOUT, il secondo a STDERR,
il terzo inoltre interrompe l'elaborazione.

precompilare obiettivi
make obiettivi
Restituisce il suo argomento alla lettera, ma prima crea tutti i file elencati. Questo è utile
quando un determinato file è necessario durante la valutazione di un'espressione make. Questo accade in genere
quando hai una build in cui l'insieme di file coinvolti viene calcolato da qualche shell
comandi. Per esempio,

file_list:
# comandi della shell per calcolare un elenco di file da inserire nel programma

mio_programma : $(&cat $(elenco_file precompilato))

Se hai bisogno dell'elenco in più di una regola, sarebbe più efficiente usare un
espandere al massimo una volta variabile:

file_list ;= $(&cat $(precostruisci file_list))

mio_programma1 : ao $(elenco_file)

mio_programma2 : bo $(elenco_file)

Se invece hai specificato solo "$(&cat file_list)", allora makepp non forzerebbe
file_list per essere aggiornato prima di eseguire il comando shell. Usando "$(precompila)"
è il modo migliore per risolvere questo problema. Potresti essere tentato di provare altre cose, come
Questo:

mio_programma: file_list $(&cat file_list)

ma questo non funzionerà perché "$(&cat file_list)" viene valutato prima che makepp tenti di farlo
costruire "elenco_file".

solo_bersagli_falsi nomi
Restituisce solo quei nomi nell'elenco che sono bersagli fasulli di qualche regola (o
regole esplicite o modello). Puoi specificare i caratteri jolly (incluso lo speciale di makepp
carattere jolly, "**") nei nomi dei file. (Vedi la funzione "$(wildcard )" per maggiori dettagli.
Questo può essere utilizzato per raggruppare obiettivi, ad esempio:

$(test fasulli): $(only_phony_targets */**/test)

origine variabile
Dato il nome di una variabile, ti dice da dove viene il suo valore.

perl codice perl
makeperl codice perl
Valuta perlcode in un blocco e restituisce il risultato. La prima variante è semplice Perl
code, mentre la seconda variante passa prima il perlcode attraverso la variabile Make-style
espansione.

Si noti che, come con tutte le funzioni, il delimitatore di funzione utilizzato potrebbe non apparire all'interno di
il perlcode al di fuori delle stringhe tra virgolette singole o doppie. Ma puoi raddoppiarlo come in
l'ultimo esempio:

VAR = 1
VAR1 = ${perl ($VAR + 1) * 3}
VAR2 = $(perl do { $VAR *= 3; restituisce $VAR + 1 } se $VAR)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # una Make var e una Perl var
VAR = $((perl se( ... ) { ... }))

falso parole
Indica che l'elenco di parole sono in realtà obiettivi fasulli e restituisce l'elenco di
obiettivi. È pensato per essere usato in questo modo:

$(tutti fasulli): mio_programma

$(falso pulito):
&rm -f *.o mio_programma

Puoi anche dichiarare uno o più bersagli come fasulli con una linea come questa ovunque in
il tuo makefile:

.FHONY: tutto pulito

stampare testo
Emette il testo e lo restituisce. Questo è principalmente utile per il debug, quando non lo fai
capire perché la sostituzione di variabile ha il risultato che ha. Per esempio,

XYZ := $(stampa $(patsubst %.c, %o, $(SOURCE_FILES)))

stamperà il risultato della chiamata "patsubst".

XYZ := $(patsubst %.c, %o, $(stampa $(FILE_SORGENTE)))

stamperà l'ultimo argomento della chiamata "patsubst".

conchiglia comando shell
Restituisce l'output del comando di shell specificato, con le nuove righe sostituite da spazi.

Si noti che, come con tutte le funzioni, il delimitatore di funzione utilizzato potrebbe non apparire all'interno di
il comando shell al di fuori delle stringhe tra virgolette singole o doppie. Ma puoi raddoppiarlo
come nel secondo esempio:

data = $(data shell) # migliore: $(ora locale scalare perl)
VAR = ${{shell f() { echo ciao; }; F}}

xargs comando,argomenti[,suffisso[,lunghezza]]
Restituisce un elenco di comandi separati da nuova riga che iniziano ciascuno con il valore specificato
comando e terminare con il maggior numero possibile di elementi dell'elenco senza andare oltre
lunghezza (predefinito 1000) caratteri.

Lo scopo di questo è di evitare di riversarsi oltre il limite di lunghezza del comando sul tuo sistema.
Ad esempio, se ci sono molti file generati, probabilmente vorrai che il tuo
clean target (che non dovresti avere, perché "makeppclean" è più efficiente) per
assomiglia a questo:

$(falso pulito):
$(xargs $(RM), $(solo_target **/*))

Questo ha anche l'effetto collaterale che non viene generato alcun comando se la lista
sembra essere vuoto. Ma in questo caso sarebbe meglio usare il &rm integrato,
perché gli argomenti dei comandi incorporati sono limitati solo dalla memoria di Perl:

$(falso pulito):
&rm -f $(only_targets **/*)

Se viene specificato un terzo argomento, viene utilizzato per postfissare ciascun comando. Questo è
utile per specificare i redirector, ad esempio (anche se anche qui &echo sarebbe d'aiuto):

manifesto:
&rm -f $@
&tocca $@
$(xargs echo, $(only_nontargets **/*), >> $@)

Parte di questa documentazione è basata sulla documentazione GNU make.

Notare che se una funzione viene chiamata durante l'inizializzazione del makefile, ad es
l'espansione delle variabili di esportazione, i messaggi di errore o di avviso riporteranno il numero di riga 0.

Usa makepp_functions online usando i servizi onworks.net