makepp_functions - Online nel cloud

PROGRAMMA:

NOME

makepp_functions -- Funzioni in makepp

DESCRIZIONE

A: nome_file_assoluto,
nome_file_assoluto_nessun_collegamento,
aspath,
aggiungiprefisso,
addsuffisso,
e, B: nome di base, C: chiamata, D: dire,
dir_noslash, E: errore, F: filesubst,
filtro,
filtro_out,
filtra_escludi_dir,
trovafile,
trova_primo_verso_l'alto,
trova_programma,
stringa di ricerca,
trova_verso l'alto,
primo_disponibile,
prima parola,
per ciascuno, I: Se,
se è vero,
infer_linker,
dedurre_oggetti,
Informazioni, J: giuntura, M: rendere,
crea una mappa,
trucco,
carta geografica,
"mktemp", N: nondir, O: solo_generato,
solo_non-bersagli,
solo_obiettivi_fasulli,
solo_stantio,
solo_obiettivi,
o,
origine, P: patsubst,
perla,
falso,
precompilare,
Stampa, R: percorso reale,
nome_file_relativo,
relativo a, S: conchiglia,
ordinare,
striscia,
sost,
suffisso, T: temporaneo, W: avvertimento,
jolly,
parola,
lista di parole,
parole, X: xargs

Qualsiasi espressione del formato "$(nome)", dove "nome" non è il nome di una variabile, o
"$(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 trattini bassi
in modo intercambiabile, poiché internamente i trattini vengono convertiti in caratteri di sottolineatura. La valutazione di tali
un'espressione richiama semplicemente una subroutine Perl. Se "nome" è preceduto da "&", esegue il comando
comando o script incorporato con quel nome all'interno del processo makepp e restituisce lo standard
output. Ciò richiede che Perl sia compilato per PerlIO. Se il nome non nomina una funzione
si trasforma in un'invocazione di chiamata.

Come con le variabili, puoi scegliere tra "$(name ...)" o "${name ...}". Se vuoi
incorporare la stessa parentesi, deve essere accoppiata, l'altra non ha importanza: "$(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". Esiste anche la sintassi "$[name ...]"
o $[[name ...]], che viene valutato durante la lettura del makefile, prima di comprendere le regole
e altri costrutti.

Makepp ha una serie di funzioni integrate che possono essere utili. Supporta quasi tutte le
Le funzioni testuali di GNU make (vedere la documentazione di GNU make per i dettagli) e alcune delle sue
proprie. Puoi definire subroutine Perl per fare ciò che vuoi. Vedi l'istruzione "sub"
e la sezione sull'estensione di makepp per maggiori dettagli.

Condizionale funzioni
e condizione1[,condizione2[,condizione3...]]
La funzione and fornisce un'operazione AND "cortocircuitante". Ogni argomento è
espanso, 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 una stringa non
stringa vuota, il risultato dell'espansione è l'espansione dell'ultimo argomento.

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

Per esempio,

CFLAGS := $(if $(filter 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 considerata vuota.

or condizione1[,condizione2[,condizione3...]]
La funzione or fornisce un'operazione OR "cortocircuitante". Ogni argomento viene espanso,
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
sono false (vuote), allora il risultato dell'espansione è la stringa vuota.

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

nome_file_assoluto_nessun_link file
percorso reale file
Simile a absolute_filename, ma garantisce che i collegamenti simbolici vengano risolti.

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

dir i nomi dei file
Estrae la parte directory di ciascun file nell'elenco dei nomi file, incluso il nome finale
barra. Restituisce "./" se il nome del file non contiene alcuna directory.

dir_noslash Nome del file
Uguale a "$(dir )", ma non restituisce la barra finale.

filesubst modello, sostituto, parole
Esegue una sostituzione di pattern sui nomi dei file. Questo differisce da patsubst in quanto
funzionerà correttamente quando vengono forniti nomi alternativi per le directory (purché
precedono il segno di percentuale). Ad esempio,

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

funzionerà con filesubst ma non con patsubst.

filtra_escludi_dir 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 di ambiente PATH se non è presente nulla.
specificato. Questo può essere utile per trovare file binari o file include. Ad esempio,

TCL_INCLUDE := -I$(dir_noslash $(findfile 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 sopra indicate. 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 può essere trovato nel PATH. Questo è utile
quando ci sono più programmi equivalenti che possono essere utilizzati e vuoi solo
scegline uno. Ad esempio, ecco la definizione predefinita di diversi termini comuni
variabili fornite da makepp se non ne inserisci una nel tuo makefile:

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

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

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

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

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

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

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

%.o: %.c
$(CC) $(CFLAGS) -I$(TOP_LEVEL_INCLUDE_DIR) -c $(input) -o $(output)

Un altro problema che "find_upwards" può aiutare a risolvere è l'individuazione della directory di livello superiore
di una build. Spesso è utile definire una variabile in questo modo:

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

se hai delle 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. In alternativa, è possibile utilizzare "find_upwards" per individuare un file che è
noto per essere presente solo nella directory di livello superiore. Supponiamo, ad esempio, che il
Il file "LICENSE" si trova solo nella directory di livello superiore. In tal caso, potresti procedere in questo modo:

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

"$(find_upwards LICENSE)" restituisce il percorso completo del file di licenza;
"$(dir_noslash ...)" rimuove 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

include 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 si specifica più di un file, find_upwards cercherà il primo, quindi
il secondo, e così via. In altre parole,

$(find_upwards file1 file2)

è equivalente

$(find_upwards file1) $(find_upwards file2)

Se si desidera cercare uno qualsiasi dei file, utilizzare invece "find_first_upwards".

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

primo_disponibile file1 file2 ...
Restituisce il primo file in un elenco esistente o che può essere compilato. Questo può essere utile per
adattare i tuoi makefile per funzionare su diverse macchine o reti, dove
I file importanti potrebbero 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 verificherà la presenza della libreria Tcl in tutti i punti sopra indicati, fermandosi a
il primo che trova. Il comando link include quindi $(TCL_LIB) quindi otteniamo
libreria Tcl appropriata.

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

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

Se si utilizzano 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 lo uso per
seleziona i file da una directory di libreria che contiene moduli utilizzati in molti modi diversi
programmi. Invece di creare un file di libreria ".a" e far sì che il linker selezioni il
moduli rilevanti, makepp può selezionare i moduli rilevanti per te. In questo modo, solo
vengono compilati i moduli pertinenti.

L'algoritmo di Makepp per dedurre 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. Controlla quali file sono stati inclusi con "#include" in
quelle fonti e cerca di trovare i file oggetto corrispondenti per ciascuna delle include
File.

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

myprog: $(infer_objects main.o another_object.o, \
**/*.o /other/library/dirs/**/*.o)
$(CXX) $(input) -o $(output) $(LIBS)

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

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

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

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

Si noti che non si desidera assegnare un nome come obiettivi e dipendenze delle regole.
il risultato sarebbe corretto, ma verrebbe ricreato ogni volta che esegui makepp.

Inoltre, poiché è sempre diverso, dovresti usarlo in un'azione di 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
produrre-As-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:
produce-As-and-Bs >$$TMPFILE # makepp non vede il valore var
fgrep -c A $$TMPFILE >A-count
fgrep -c B $$TMPFILE >B-count

L'ultima forma ripete il valore di ritorno precedente, quindi è possibile utilizzarla in una regola modello:

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

nondir i nomi dei file
Restituisce la parte non directory del nome del file, ovvero tutto ciò che segue l'ultimo
barra se presente, altrimenti l'intero nome del file.

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

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

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

solo_non-obiettivi i nomi dei file
Restituisce solo i nomi di file nell'elenco che non sono target di alcuna regola (o
regole esplicite o di pattern). È possibile specificare un carattere jolly (vedere "$(wildcard )"
funzione per maggiori dettagli sui caratteri jolly di makepp). Questo può essere utilizzato per generare un
obiettivo di distribuzione, ad esempio:

.PHONY: distribuzione

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

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

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

solo_stantio i nomi dei file
Restituisce solo i nomi dei file nell'elenco che sono stati generati da makepp e non da allora
modificati, secondo il file di informazioni sulla build, ma non sono più oggetto di alcuna regola.

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

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

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

solo_obiettivi i nomi dei file
Restituisce solo i nomi di file nell'elenco che sono effettivamente obiettivi di una regola
(regole esplicite o di pattern). È possibile specificare caratteri jolly (inclusi quelli di makepp)
carattere jolly speciale, "**") nei nomi dei file. (Vedi la funzione "$(wildcard )" per maggiori informazioni
dettagli. Questo può essere utilizzato per un obiettivo pulito, ad esempio:

.FONO: pulito

pulito:
&rm -f $(solo_target *)

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

Un altro posto in cui potrebbe essere utile è evitare di includere stantio .o file nel tuo
build. Ad esempio, se si crea una libreria come questa:

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

e poi elimini alcuni file sorgente ma dimentichi di eliminare quelli corrispondenti .o File,
, il .o i file saranno ancora in circolazione. Ciò significa che saranno ancora incorporati in
la libreria nonostante il fatto che non siano più utili. Se modifichi il tuo
regola come questa:

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

allora questo problema non si verificherà.

Si noti che questo si riferisce solo ai file che sono noti come obiettivi at , il tempo Tu
invocare "only-targets". Se "only_targets" appare nelle dipendenze o nelle azioni di un
regola, allora tutti i possibili obiettivi saranno noti perché le dipendenze e le azioni non sono
valutato finché la regola non viene eseguita. Tuttavia, se si valuta, provare a valutarlo
in precedenza nel makefile con una variabile ":" come questa:

TUTTI_OBIETTIVI := $(solo_obiettivi *)

target1: dipendenza1
azioni

target2: dipendenza2
azioni

quindi "only_targets" non conoscerà le 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.)

nome_file_relativo file1 file2 file3[, barra]
Restituisce il nome di quei file relativi alla directory corrente (quella in cui si trova il
makefile è in). Questo può anche essere usato per pulire "./" non necessari e altri file indesiderati da
il percorso:

DIR := .
SOTTODIR := ..
FNAME := $(DIR)/../altradir/$(SUBDIR)/file
X := $(nome_file_relativo $(FNAME))

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

Se il percorso passa per la directory radice, la directory padre della tua home directory o
"$(ROOT)" del tuo sistema di build, o su Windows la radice di un'unità (a seconda del
ambiente, questo accade anche per /cygdrive/c or /c), un percorso assoluto sarà
invece è tornato.

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

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

suffisso nomi...
Estrae il suffisso di ogni nome di file in names. Se il nome del file contiene un punto,
il suffisso è tutto ciò che inizia con l'ultimo punto. Altrimenti, il suffisso è il
stringa vuota. Ciò significa spesso che il risultato sarà vuoto quando names non lo è,
e se names contiene più nomi di file, il risultato potrebbe contenere meno nomi di file.

Per esempio,

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

produce il risultato ".c .c".

temporaneo parole
Fai sapere a makepp che i target specificati potrebbero essere rimossi dalla regola che genera
loro. Simile a "phony", tranne per il fatto che makepp si aspetta che un file reale con quel nome
potrebbe essere influenzato dalla regola. Una regola non viene eseguita se solo la sua durata temporanea
gli obiettivi sono obsoleti.

jolly modello
Restituisce i nomi ordinati di tutti i file che corrispondono al modello specificato che esistono, o quelli
file che non esistono ancora ma che possono essere creati 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 dalle regole trovate in seguito.

Makepp supporta tutti i soliti caratteri jolly della shell ("*", "?" e "[]"). Ha anche un
carattere jolly "**" che corrisponde a un numero qualsiasi di directory intermedie. (Questa idea è stata
rubato da zsh.) Ad esempio, "**/*.c" corrisponde a tutti i .c file nell'intera sorgente
albero. "objects/**/*.o" corrisponde a tutti gli .o file contenuti ovunque nel
sottodirectory oggetti o una qualsiasi delle sue sottodirectory o una qualsiasi delle loro sottodirectory. Il
Il carattere jolly "**" non seguirà i collegamenti soft 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
aggiungiprefisso prefisso, parole
Aggiunge la stringa di prefisso a ciascuna parola. Questo è principalmente per GNU Make.
compatibilità; utilizzando l'espansione in stile rc, questo può essere fatto in modo più leggibile
come questo:

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

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

X_OLD_STYLE := $(addsuffix .o, $(MODULES))
X_NEW_STYLE := $(MODULI).o

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

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

Non c'è limite al numero di argomenti con cui una macro può essere "chiamata" o al numero di
parametri che una macro può aspettarsi. Se si passano più argomenti a "call" come macro
need, tutti gli argomenti in eccesso verranno scartati. Se si passano meno argomenti di un
macro expect, tutti i parametri in eccesso vengono compressi nella stringa vuota.

Innanzitutto un semplice esempio:

resto = $(elenco parole 2, $(parole $(1)),$(1))
elenco = ABCDE
ma prima := $(call rest,$(list))

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

E ora un esempio più complesso per mostrare cosa è possibile:

resto = $(elenco parole 2,$(parole $(1)),${1})
mymap = $(if $2,$(call $1,$(firstword $2)) $(call $0,$1,$(call rest,$2)))
minuscolo = ${makeperl lc("$1")}

UCWORDS = TUTTE QUESTE PAROLE SONO IN FORMATO UPCASE
DCWORDS := $(chiama la mia mappa, minuscolo, $(UCWORDS))

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

È possibile utilizzare direttamente la variabile come se fosse una funzione, se non c'è
funzione con quel nome. Questo viene convertito internamente in "chiamata", quindi queste sono
equivalente:

discussione = Lo $0 si è trasformato in $1 $2.
diretto = $(discussione un,argomento)
chiamato = $(chiama discussione,un,argomento)

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

definisci la mia regola
$ 2: $ 1
miocomando $$(input) -o $$(output)
fine
$[myrule myinput,myoutput]

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

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

Per esempio:

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

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

stringa di ricerca trova, in
LUOGO DI RICONSEGNA Find, se è una sottostringa di in.

prima parola parole
Restituisci la prima parola.

carta geografica parole, codice perl
makemap parole, codice perl
Similmente alla mappa di Perl, si applica codice perl a ogni parola a turno e restituisce il
risultati. La prima variante è semplice codice Perl, mentre la seconda variante passa prima
il perlcode tramite l'espansione delle variabili in stile Make. Le parole vengono espanse in entrambi
casi.

Le parole sono in $_ e vengono restituite a meno che non si defi nisca $_. 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. Raddoppia le parentesi per consentirle in Perlcode, oppure usa ${}:
X = $((map $(VALUES), s/(.+)-(.+)/$2-$1/))
# Puoi usare le espressioni make, ma poi devi usare $$ per Perl $:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ o $$_ = 'fallito')
# È possibile eliminare i candidati:
Y = $(map $(VALUES), undef $_ if /no_good/)

join parole1, parole2
Unisci a coppie le prime e le seconde parole.

patsubst modello, sostituto, parole
Esegue una sostituzione su ogni parola nell'elenco di parole. Un carattere "%" corrisponde a qualsiasi
stringa. 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=object_dir/%.o)

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

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

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

$(subst ee,EE,piedi sulla strada)

sostituisce la stringa "fEEt on the strEEt".

parola n,testo
Restituisce il nparola di testoI valori legittimi di n iniziare da 1 all'inizio
o all'indietro da -1 alla fine. Se n è più grande del numero di parole in testo, l'
il valore è vuoto.

lista di parole elenco indici, parole
lista di parole primoindice, ultimo indice, parole
Nella prima forma si fornisce un elenco di indici (contando da 1 all'inizio o
all'indietro da -1 alla fine) per selezionare le parole desiderate. Nella seconda forma puoi
specifica l'intervallo di parole che vuoi che vengano restituite.

parole testo
Restituisce il numero di parole in testo.

Miscellanea funzioni
foreach var,elenco,testo
I primi due argomenti, var e stratagemma, vengono espansi prima che venga fatto qualsiasi altro cosa; nota
che l'ultimo argomento, il testo, non viene espanso allo stesso tempo. Quindi per ogni parola di
il valore espanso dell'elenco, 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à diversa ogni volta.

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

dirs := abcd
file := $(foreach dir,$(dirs),$(carattere jolly $(dir)/*))

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

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

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

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

trova_file = $(carattere jolly $(dir)/*)
dirs := abcd
file := $(foreach dir,$(dirs),$(find_files))

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

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

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

precompilare obiettivi
make obiettivi
Restituisce il suo argomento alla lettera, ma prima crea tutti i file elencati. Questo è utile
quando un dato file è necessario per valutare un'espressione make. Questo accade in genere
quando si ha una build in cui l'insieme dei file coinvolti viene calcolato da una shell
comandi. Per esempio,

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

my_program : $(&cat $(prebuild file_list))

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

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

my_program1 : ao $(file_list)

my_program2 : bo $(file_list)

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

mio_programma : elenco_file $(&cat elenco_file)

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

solo_obiettivi_fasulli nomi
Restituisce solo i nomi nell'elenco che sono obiettivi falsi di qualche regola (o
regole esplicite o pattern). È possibile specificare caratteri jolly (inclusi quelli speciali di makepp)
carattere jolly, "**") nei nomi dei file. (Vedi la funzione "$(wildcard )" per maggiori dettagli.
Può essere utilizzato per raggruppare gli obiettivi, ad esempio:

$(test falsi): $(only_phony_targets */**/tests)

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

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

Si noti che, come con tutte le funzioni, il delimitatore di funzione utilizzato potrebbe non apparire all'interno
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; return $VAR + 1 } se $VAR)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # una var Make e una var Perl
VAR = $((perl if( ... ) { ... }))

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

$(phony all): my_program

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

Puoi anche dichiarare uno o più obiettivi come falsi con una riga come questa ovunque in
il tuo makefile:

.PHONY: tutto pulito

stampare testo
Emette il testo e lo restituisce. Questo è utile soprattutto per il debug, quando non si desidera
capire perché la sostituzione delle variabili produce il risultato che produce. Ad esempio,

XYZ := $(print $(patsubst %.c, %o, $(FILE_ORIGINE)))

stamperà il risultato della chiamata "patsubst".

XYZ := $(patsubst %.c, %o, $(print $(FILE_ORIGINE)))

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

conchiglia comando shell
Restituisce l'output del comando 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
il comando shell al di fuori delle stringhe tra virgolette singole o doppie. Ma puoi raddoppiarlo
come nel secondo esempio:

data = $(shell date) # meglio: $(perl scalar localtime)
VAR = ${{shell f() { echo hello; }; f}}

xargs comando,argomenti[,suffisso[,lunghezza]]
Restituisce un elenco di comandi separati da nuove righe, ognuno dei quali inizia con il valore specificato
comando e termina con quanti più elementi possibili dell'elenco senza superarli
lunghezza (predefinito 1000) caratteri.

Lo scopo è evitare di superare il limite di lunghezza dei comandi sul sistema.
Ad esempio, se ci sono molti file generati, allora probabilmente vorresti che il tuo
target pulito (che non dovresti avere, perché "makeppclean" è più efficiente) per
assomiglia a qualcosa del genere:

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

Ciò ha anche l'effetto collaterale che non viene generato alcun comando se l'elenco
risulta essere vuoto. Ma in questo caso sarebbe meglio usare il built-in &rm,
perché gli argomenti dei comandi predefiniti sono limitati solo dalla memoria di Perl:

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

Se viene specificato un terzo argomento, questo viene utilizzato per aggiungere un suffisso a ciascun comando. Questo è
utile per specificare i redirector, ad esempio (anche se anche in questo caso &echo sarebbe utile):

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

Parte di questa documentazione si basa sulla documentazione GNU make.

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

Utilizzare makepp_functions online utilizzando i servizi onworks.net