makepp_functions - Online in de cloud

PROGRAMMA:

NAAM

makepp_functions -- Functies in makepp

PRODUCTBESCHRIJVING

A: absolute_bestandsnaam,
absolute_bestandsnaam_nolink,
abspath,
voorvoegsel toevoegen,
voegt achtervoegsel toe,
en, B: basisnaam, C: bellen, D: richt,
dir_noslash, E: fout, F: bestandssubst,
filters,
uitfilteren,
filter_uit_dirs,
vind bestand,
vind_eerst_omhoog,
zoek_programma,
vindreeks,
vind_omhoog,
eerste_beschikbaar,
eerste woord,
voor, I: als,
als het klopt,
infer_linker,
afleiden_objecten,
informatie, J: toetreden, M: maken,
makemap,
makeperl,
kaart,
"mktemp", N: notdir, O: alleen_gegenereerd,
alleen_nontargets,
alleen_nep_doelen,
alleen_oud,
alleen_doelen,
of,
oorsprong, P: Patsubst,
perl,
nep,
voorbouw,
afdrukken, R: echtpad,
relatieve_bestandsnaam,
in verhouding tot, S: shell,
soort,
strip,
plaatsvervanger,
achtervoegsel, T: tijdelijk, W: waarschuwing,
wildcard,
woord,
woordenlijst,
woorden, X: xargs

Elke expressie met het formaat "$(naam)", waarbij "naam" niet de naam van een variabele is, of
"$(naam arg1 arg2 arg3)" wordt geïnterpreteerd als een functieaanroep. De naam kan letters bevatten,
onderstrepingstekens of koppeltekens; Om verwarring te voorkomen, kunt u koppeltekens of onderstrepingstekens gebruiken
door elkaar, aangezien intern koppeltekens worden omgezet in onderstrepingstekens. Het evalueren van dergelijke
een expressie roept eenvoudigweg een Perl-subroutine aan. Als "naam" wordt voorafgegaan door "&", wordt de
ingebouwde opdracht of script met die naam binnen het makepp-proces en retourneert de standaard
uitgang. Hiervoor moet perl worden gebouwd voor PerlIO. Als de naam geen functie noemt
het wordt getransformeerd in een aanroep van oproep.

Net als bij variabelen heb je de keuze uit "$(naam ...)" of "${naam ...}". Als je wilt
hetzelfde haakje insluiten, het moet gepaard zijn, het andere doet er niet toe: "$(name
...(){..." of "${name ...{}(...}". (Voor map en perl eindigt het eerste afsluitende bovenliggende element echter
de uitdrukking.) Door te verdubbelen kunnen de argumenten meerdere regels beslaan. De nieuwe regels zijn
vervolgens behandeld als spaties, behalve misschien in "define". Er is ook de syntaxis "$[naam ...]"
of $[[naam ...]], dat wordt geëvalueerd tijdens het lezen van het makefile, vóór het grokken van de regels
en andere constructies.

Makepp heeft een aantal ingebouwde functies die handig kunnen zijn. Het ondersteunt bijna alles
De tekstuele functies van GNU make (zie de documentatie van GNU make voor details), en enkele daarvan
eigen. U kunt Perl-subroutines definiëren om te doen wat u maar wilt. Zie de "sub" -verklaring
en het gedeelte over het uitbreiden van makepp voor meer details.

Voorwaardelijk Functies
en voorwaarde1[,voorwaarde2[,voorwaarde3...]]
De functie en zorgt voor een "kortsluiting" EN-bewerking. Elk argument is
uitgebreid, op volgorde. Als een argument zich uitbreidt naar een lege string, stopt de verwerking en
het resultaat van de uitbreiding is de lege string. Als alle argumenten uitbreiden naar een niet-
lege string dan is het resultaat van de uitbreiding de uitbreiding van het laatste argument.

if draad, resultaat-als-string-niet-blank[, resultaat-als-string-leeg]
als het klopt draad, resultaat-als-string-waar[, resultaat-als-string-false]
Een alternatief voor de "ifeq", enz., uitspraken. Als de string niet leeg is (dat wil zeggen, de
voorwaarde waar is), wordt het tweede argument (de "then"-clausule) geretourneerd (after
variabele expansie); als de string leeg is, is het derde argument (de "else"-clausule) dat ook
teruggekeerd.

Bijvoorbeeld

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

definieert CFLAGS als "-g -Wall" als de variabele CC "gcc" of "egcc" is, en "-g"
anders. (Dit is wat de standaard buildregels doen.)

"iftrue" is vergelijkbaar met "if", behalve dat de string 0 als blanco wordt behandeld.

or voorwaarde1[,voorwaarde2[,voorwaarde3...]]
De of-functie zorgt voor een "kortsluiting" OF-bewerking. Elk argument wordt uitgebreid,
in volgorde. Als een argument zich uitbreidt naar een niet-lege tekenreeks, stopt de verwerking en wordt de
resultaat van de uitbreiding is die string. Als, nadat alle argumenten zijn uitgebreid, alle
Als deze onwaar (leeg) zijn, is het resultaat van de uitbreiding de lege string.

Dien in en Bestandsnaam Functies
absolute_bestandsnaam bestanden
abspathisch bestanden
Converteert relatieve bestandsnamen naar absolute waarden zonder . or ... Bijvoorbeeld,
"$(absolute_filename xyz.c)" retourneert mogelijk "/usr/src/our_project/subdir/xyz.c".

absolute_bestandsnaam_nolink bestanden
echt pad bestanden
Net als absolute_bestandsnaam, maar zorgt ervoor dat symbolische koppelingen worden opgelost.

basisnaam bestandsnamen
De basisnaam is de volledige bestandsnaam (met de map), minus de tekst na en
inclusief de laatste periode. Bijvoorbeeld: "$(basisnaam mijnbestand/versie-1.0-module.c)" is
"mijnbestand/versie-1.0-module"

dir bestandsnamen
Extraheert het mapgedeelte van elk bestand in de bestandsnaamlijst, inclusief het volgende
schuine streep. Retourneert "./" als de bestandsnaam geen directory bevat.

dir_noslash bestandsnaam
Hetzelfde als "$(dir )" behalve dat het niet de afsluitende slash retourneert.

bestandssubst patroon, plaatsvervanger, woorden
Voer een patroonvervanging uit op bestandsnamen. Daarin verschilt dit van patsubst
het zal correct werken als er alternatieve namen voor mappen worden opgegeven (zolang als
ze staan ​​vóór het procentteken). Bijvoorbeeld,

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

werkt met filesubst maar niet met patsubst.

filter_uit_dirs bestandsnamen
Retourneert alle bestandsnamen die niet naar mappen verwijzen.

vind bestand bestandsnaam, pad
Zoekt een bestand in het opgegeven pad, of in de omgevingsvariabele PATH als er niets is
gespecificeerd. Dit kan handig zijn voor het vinden van binaire bestanden of het opnemen van bestanden. Bijvoorbeeld,

TCL_INCLUDE := -I$(dir_noslash $(zoekbestand 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))

Hiermee wordt het bestand gelokaliseerd tcl.h door in alle bovenstaande mappen te zoeken. Het absolute
pad naar het bestand wordt geretourneerd. Vervolgens extraheert "$(dir_noslash)" die map, en deze
wordt in het include-pad geplaatst.

vind_programma naam
Retourneer het eerste programma in de lijst dat in PATH te vinden is. Dit is nuttig
wanneer er meerdere gelijkwaardige programma's zijn die kunnen worden gebruikt, en u wilt dat gewoon
kies er een uit. Hier is bijvoorbeeld de standaarddefinitie van verschillende algemene
variabelen die makepp levert als je er geen in je makefile plaatst:

CC = $(find_program gcc egcc pgcc c89 cc) # en meer, afhankelijk van de machine
F77 = $(zoekprogramma f77 g77 fort77)
CXX = $(zoek_programma g++ c++ pg++ cxx CC aCC)

Als geen van de programma's wordt gevonden, retourneert "$(find_program )" de tekenreeks not-found, en
registreert wat niet is gevonden. Dit resulteert meestal niet in een functioneel makefile, maar het is het wel
zal de neiging hebben om betere foutmeldingen te geven. Als je bijvoorbeeld zoiets doet
deze:

%.o: %.c
$(CC) $(ingangen) -o $(uitgangen)

en makepp kan geen C-compiler vinden in de bovenstaande lijst, deze zal not-found vervangen.
Anders zou de shell proberen het bronbestand en de resulterende fout uit te voeren
bericht kan heel vreemd zijn.

vind_naar boven bestandsnaam
Zoekt naar een bestand met de opgegeven naam in de map ., .., ../..​/../.., Enz.
totdat het bestand is gevonden of de hoofdmap is bereikt of de map is gevonden
op een ander bestandssysteem. (Deze laatste vereiste is om problemen met
automounters of vastgelopen netwerkbestandssystemen.) Als u een RootMakepp-bestand, dat is ook zo
een barrière die hoger zoeken verhindert.

Als u bijvoorbeeld een project heeft met veel niveaus van submappen, kunt u dat doen
neem dit algemene fragment op in alle makefiles (bijvoorbeeld door de optie "include" te gebruiken
uitspraak):

TOP_LEVEL_INCLUDE_DIR:= $(find_upwards omvat)
# Zoekt naar een map die de
# bevat submap.

%.o: %.c
$(CC) $(CFLAGS) -I$(TOP_LEVEL_INCLUDE_DIR) -c $(invoer) -o $(uitvoer)

Een ander probleem dat "find_upwards" kan helpen oplossen is het lokaliseren van de map op het hoogste niveau
van een constructie. Vaak is het handig om een ​​variabele als volgt te definiëren:

TOP := ../../..

als u belangrijke informatie alleen in de map op het hoogste niveau heeft. Maar
dit is moeilijk vol te houden, omdat het aantal ".." voor verschillende niveaus verschillend is
van de directorystructuur. In plaats daarvan kunt u "find_upwards" gebruiken om een ​​bestand te vinden dat dat wel is
waarvan bekend is dat deze alleen aanwezig is in de map op het hoogste niveau. Stel bijvoorbeeld dat de
bestand "LICENSE" bevindt zich alleen in de map op het hoogste niveau. Dan zou je dit kunnen doen:

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

"$(find_upwards LICENSE)" retourneert het volledige pad van het licentiebestand;
"$(dir_noslash ...)" verwijdert de bestandsnaam en retourneert alleen de map.

(Merk op dat de instructie "include" automatisch naar boven zoekt naar bestanden, dus daar
het is niet nodig om zoiets als dit te doen:

inclusief $(find_upwards top_level_rules.mk)

In plaats daarvan kun je het gewoon doen

neem top_level_rules.mk op

en het zal net zo goed werken.)

Als het bestand niet wordt gevonden, zal "find_upwards" de build afbreken met een foutmelding.

Als u meer dan één bestand opgeeft, zoekt find_upwards naar het eerste bestand
de tweede, enzovoort. Met andere woorden,

$(vind_omhoog bestand1 bestand2)

is gelijk aan

$(find_upwards bestand1) $(find_upwards bestand2)

Als u naar een van de bestanden wilt zoeken, gebruik dan in plaats daarvan "find_first_upwards".

vind_eerst_naar boven file1 file2 ...
Deze functie gedraagt ​​zich als "find_upwards", behalve dat het het eerste bestand van een bestand retourneert
bestanden in de lijst die het vindt. Concreet controleert het de huidige map
elk van de bestanden in de lijst en retourneert het eerste bestand dat bestaat of kan worden gebouwd.
Als geen van de bestanden in die map bestaat of kan worden gebouwd, wordt dit gecontroleerd ..dan
../.., enz., totdat het de hoofdmap bereikt of een map die dat wel is
zich op een ander bestandssysteem bevindt.

eerste_beschikbaar file1 file2 ...
Retourneert het eerste bestand in een lijst die bestaat of kan worden gebouwd. Dit kan handig zijn voor
het aanpassen van uw makefiles om op verschillende machines of netwerken te werken, waar
belangrijke bestanden kunnen zich op verschillende plaatsen bevinden. Hier is bijvoorbeeld een regel uit
een van mijn makefiles:

TCL_LIB = $(eerste_beschikbaar \
/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)

Deze regel controleert op alle bovenstaande plaatsen de Tcl-bibliotheek en stopt bij de
eerste die hij vindt. Het linkcommando bevat dan $(TCL_LIB), zodat we de
geschikte Tcl-bibliotheek.

infer_linker file1 file2 ...
Gegeven een lijst met objectbestanden, bouw deze dan eerst als ze er nog niet zijn. Vind dan
of ze afhankelijk zijn van een Fortran-, C++- of C-bron en de overeenkomstige retourneren
compiler (die beter weet hoe te linken dan "ld").

afleiden_objecten file1 file2 ..., patroon
$(infer_objects object1.o object2.o, *.o)

Als u standaardconventies gebruikt met betrekking tot headerbestandsnamen, is makepp daartoe in staat
raden welke ".o"- of ".lo"-bestanden aan uw programma moeten worden gekoppeld. Ik gebruik dit om
kies bestanden uit een bibliotheekmap die modules bevat die in veel verschillende toepassingen worden gebruikt
programma's. In plaats van een bibliotheek ".a"-bestand te maken en de linker de .a-bestanden te laten kiezen
relevante modules, makepp kan de relevante modules voor u uitzoeken. Alleen op deze manier
de relevante modules worden samengesteld.

Het algoritme van Makepp voor het afleiden van objectafhankelijkheden hangt af van de conventie dat
de implementatie van alle klassen of functies die zijn gedefinieerd in een headerbestand "xyz.h".
gecompileerd in een objectbestand genaamd "xyz.o" (of "xyz.lo"). Dus makepp's algoritme voor
het afleiden van objectafhankelijkheden begint met een of enkele objecten waarvan we weten dat ze dat moeten zijn
gekoppeld aan het programma. Er wordt gekeken naar welke bestanden zijn opgenomen met "#include" erin
die bronnen, en probeert corresponderende objectbestanden voor elk van de include-bestanden te vinden
bestanden.

"$(infer_objects )" moet worden vermeld in de afhankelijkheidslijst van een programma, bijvoorbeeld
deze:

myprog: $(infer_objects main.o another_object.o, \
**/*.o /andere/bibliotheek/dirs/**/*.o)
$(CXX) $(invoer) -o $(uitvoer) $(LIBS)

De functie "$(infer_objects)" heeft twee argumenten nodig (gescheiden door een komma, zoals weergegeven).
De eerste is een of enkele objectbestanden waarvan bekend is dat ze vereist zijn (jokertekens zijn
hier toegestaan). De tweede is een lijst met mogelijke objecten (normaal gesproken zou je een
wildcard hier) die indien nodig kunnen worden gekoppeld. De retourwaarde hiervan
functie is een lijst die eerst alle objecten in het eerste argument bevat, en
en daarna alle aanvullende objecten die in het tweede argument waren opgenomen
die vereist zijn door de objecten in het eerste argument.

Stel bijvoorbeeld dat "main.o" afkomstig is van "main.cpp", inclusief "my_class.h".
"$(infer_objects)" zoekt naar bestanden met de naam "my_class.o". Als het precies zo is
bestand wordt gevonden, wordt het aan de lijst toegevoegd. (Als er twee objectbestanden "my_class.o" worden gevonden
in verschillende mappen wordt een waarschuwingsbericht afgedrukt.) ook "infer_objects".
onderzoekt "my_class.cpp" om te zien wat het bevat, en wat extra objectbestanden zijn
geïmpliceerd.

mktemp
mktemp voorvoegsel
mktemp voorvoegselXXX
mktemp /
Retourneert een onvoorspelbare tijdelijke bestandsnaam, die momenteel niet bestaat. Geen naam
die naar hetzelfde bestand verwijst, wordt twee keer geretourneerd, zelfs met verschillende relatieve paden,
binnen één makepp-run (behalve mogelijk met traditionele recursieve make, of als Perl
code die binnen een regelactie wordt uitgevoerd, roept "f_mktemp") aan. Aan het einde van de makepp wordt alles uitgevoerd
bestanden die door deze functie worden geretourneerd, worden verwijderd als ze bestaan ​​(opnieuw, behalve degenen
geretourneerd door deze functie in Perl-code die binnen een regel wordt uitgevoerd).

Een willekeurig aantal hoofdletters "X" aan het einde van het argument wordt vervangen door zoveel
willekeurige letters en cijfers. Hoe meer er zijn, hoe kleiner de kans dat dit botst
met andere processen, dus als u een voorvoegsel geeft zoals "/tmp/abc.", je zou genoeg moeten hebben
"X"-en. Als er meer dan één X is, komt het eerste teken uit de proces-ID. Als
die zijn er niet, het is alsof er tien zijn, wat vermoedelijk voldoende is (8.4e17
mogelijkheden of 3.7e15 op Windows). Als er geen argument is, wordt het voorvoegsel standaard ingesteld op
"tmp." in de huidige map.

Houd er rekening mee dat u een dergelijke naam niet wilt geven als regeldoelen en afhankelijkheden. De
het resultaat zou correct zijn, maar het zou elke keer dat u makepp uitvoert opnieuw worden gemaakt.

Omdat het altijd anders is, moet u dit ook alleen in een regelactie gebruiken als u gebruikt
":build_check negeer_actie":

TMPFILE ;= $(mktemp) # 1 oproep; "=" zou 3 oproepen betekenen: 3 bestanden
A-telling B-telling: :build_check negeer_actie
produceren-As-and-Bs >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o A-telling
&grep -c /B/ $(TMPFILE) -o B-telling

Of u moet het exporteren en Shell het laten evalueren:

TMPFILE exporteren ;= $(mktemp)
A-telling B-telling:
produce-As-and-Bs >$$TMPFILE # makepp ziet de var-waarde niet
fgrep -c A $$TMPFILE >A-telling
fgrep -c B $$TMPFILE >B-telling

Het laatste formulier herhaalt de vorige retourwaarde, zodat u deze in een patroonregel kunt gebruiken:

%.x: %.y
&grep foo $(invoer) -o $(mktemp)
&sed bar $(mktemp /) -o $(output) # Bewerken op de uitvoer van &grep

nietdir bestandsnamen
Retourneert het niet-directorygedeelte van de bestandsnaam(en), dwz alles na de laatste
schuine streep als die er is, of anders de hele bestandsnaam.

alleen_gegenereerd bestandsnamen
Retourneert alleen de bestandsnamen in de lijst die zijn gegenereerd door makepp en niet sindsdien
aangepast, volgens het build-infobestand.

Deze functie is handig bij schone doelregels (hoewel "makeppclean" natuurlijk de
voorkeursvariant):

$(nepschoon):
&rm -f $(only_generated **/*)

alleen_nontargets bestandsnamen
Retourneert alleen die bestandsnamen in de lijst die geen doelwit zijn van een regel (ofwel
expliciete of patroonregels). U kunt een wildcard opgeven (zie de "$(wildcard)"
functie voor meer details over de jokertekens van makepp). Dit kan worden gebruikt voor het genereren van een
distributiedoel, bijvoorbeeld:

.PHONY: distributie

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

In dit geval retourneert "$(only_nontargets *)" elk bestand in de huidige map
dat is niet het doel van een bepaalde regel. De "$(filter_out %~, ...)" verwijdert de editor
back-ups.

Net als bij "only_targets" (zie hierboven), kent "only_nontargets" alleen de doelen die
zijn al gedefinieerd. Dit is alleen een probleem als u het gebruikt om variabelen te definiëren
met de ":=" toewijzing; als u het gebruikt in de afhankelijkheidslijst of in de hoofdtekst van a
regel, zijn alle andere regels al gezien.

alleen oud bestandsnamen
Retourneert alleen de bestandsnamen in de lijst die zijn gegenereerd door makepp en niet sindsdien
gewijzigd, volgens het build-infobestand, maar zijn niet langer het doelwit van welke regel dan ook.

Deze functie is handig om ervoor te zorgen dat er geen afhankelijkheden zijn van dergelijke bestanden,
zonder een schone bouw van alle doelen te forceren:

$(nepspoeling):
&rm -f $(only_stale **/*)

Eigenlijk is het waarschijnlijk beter om in plaats daarvan een script te schrijven dat makepp aanroept om te genereren
de lijst met verouderde bestanden en laat dat script vervolgens alle vermelde bestanden verwijderen
staan ​​momenteel niet onder broncontrole, voor het geval een gegenereerd bestand een bron wordt
bestand. Makepp heeft zo'n functie niet ingebouwd omdat makepp (en waarschijnlijk
zou agnostisch moeten blijven als het om broncontrole gaat.

alleen_doelen bestandsnamen
Retourneert alleen die bestandsnamen in de lijst die feitelijk het doelwit zijn van een bepaalde regel
(hetzij expliciete regels, hetzij patroonregels). U kunt jokertekens opgeven (inclusief makepp's
speciaal jokerteken, "**") in de bestandsnamen. (Zie de functie "$(wildcard)" voor meer informatie
details. Dit kan worden gebruikt voor een schoon doel, bijvoorbeeld:

.PHONY: schoon

schoon:
&rm -f $(alleen_doelen *)

Als u nu "makepp clean" typt, wordt alles verwijderd waarvan het weet hoe het moet worden gebouwd. Maar
maak geen schoon doel, gebruik in plaats daarvan "makeppclean"!

Een andere plaats waar het nuttig kan zijn, is het vermijden van oudbakken eten .o bestanden in uw
bouwen. Als u bijvoorbeeld een bibliotheek als volgt bouwt:

mijnlib.a: *.o
&rm -f $(uitvoer)
$(AR) cr $(uitvoer) $(invoer)

en dan verwijder je enkele bronbestanden, maar vergeet je de bijbehorende te verwijderen .o bestanden,
de .o bestanden zullen er nog steeds zijn. Dit betekent dat ze nog steeds in het programma zullen worden opgenomen
de bibliotheek ondanks het feit dat ze niet meer bruikbaar zijn. Als u uw
regel als volgt:

mijnlib.a: $(only_targets *.o)
&rm -f $(uitvoer)
$(AR) cr $(uitvoer) $(invoer)

dan zal dit probleem niet optreden.

Houd er rekening mee dat dit alleen betrekking heeft op bestanden waarvan bekend is dat ze doelwitten zijn at de niet de tijd of u
inroepen "enige doelwitten". Als "only_targets" verschijnt in de afhankelijkheden of acties van a
regel, dan zullen alle mogelijke doelen bekend zijn, omdat afhankelijkheden en acties dat niet zijn
geëvalueerd totdat de regel wordt uitgevoerd. Als je echter evalueert, probeer het dan te evalueren
eerder in het makefile met een ":=" variabele zoals deze:

ALL_TARGETS := $(alleen_targets *)

doel1: afhankelijkheid1
acties

doel2: afhankelijkheid2
acties

dan weet "only_targets" niets van de daaropvolgende regels.

Op dezelfde manier weet "only_targets" niets over doelen die zijn geproduceerd in makefiles die dat wel zijn
geladen met recursieve make. (Maar je zou sowieso geen recursieve make moeten gebruiken; use
gebruik de instructie "load_makefile" of impliciet laden van makefile.)

relatieve_bestandsnaam file1 file2 bestand3[, schuine streep]
Retourneert de naam van die bestanden ten opzichte van de huidige map (degene die de
make-bestand is aanwezig). Dit kan ook worden gebruikt om onnodige "./" en andere rommel te verwijderen
het pad:

DIR := .
ONDERDIR := ..
FNAME := $(DIR)/../andere map/$(SUBDIR)/bestanden
X := $(relatieve_bestandsnaam $(FNAME))

If snijden is waar (meestal 1) de geretourneerde bestandsnamen bevatten gegarandeerd een schuine streep
door indien nodig "./" voor te zetten, zodat u het als uitvoerbare naam kunt gebruiken zonder
zorgen maken over het zoekpad van de opdracht dat de maplocatie overschrijft.

Als het pad langs de hoofdmap loopt, wordt de bovenliggende map van uw thuismap of
de "$(ROOT)" van uw buildsysteem, of in Windows de root van een schijf (afhankelijk van de
milieu, dit gebeurt ook voor /cygdrive/c or /c), zal een absoluut pad zijn
in plaats daarvan teruggekeerd.

in verhouding tot file1 file2 bestand3[, map]
Retourneert de naam van die bestanden ten opzichte van de opgegeven map. Dit is
meestal handig wanneer u om welke reden dan ook een opdracht uit a moet uitvoeren
andere map (standaard huidige map):

bron_backup.tar:
cd .. && tar cf $(relatief_naar $(uitvoer), ..) $(relatief_naar ., ..)

achtervoegsel namen...
Extraheert het achtervoegsel van elke bestandsnaam in namen. Als de bestandsnaam een ​​punt bevat,
het achtervoegsel is alles dat begint met de laatste punt. Anders is het achtervoegsel de
lege tekenreeks. Dit betekent vaak dat het resultaat leeg zal zijn als namen dat niet zijn,
en als namen meerdere bestandsnamen bevatten, kan het resultaat minder bestandsnamen bevatten.

Bijvoorbeeld

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

levert het resultaat ".c .c" op.

tijdelijk woorden
Laat makepp weten dat de opgegeven doelen kunnen worden verwijderd door de regel die wordt gegenereerd
hen. Vergelijkbaar met "nep", behalve dat makepp verwacht dat een echt bestand met die naam
De wil kan door de regel worden beïnvloed. Een regel wordt niet uitgevoerd als deze slechts tijdelijk is
doelstellingen zijn verouderd.

wildcard patroon
Geeft de gesorteerde namen terug van alle bestaande bestanden die overeenkomen met het gegeven patroon, of die
bestanden die nog niet bestaan, maar gebouwd kunnen worden op basis van de regels die makepp kent
ongeveer op het punt waarop de uitdrukking wordt geëvalueerd. Op dit laatste punt verschilt het
van jokertekens voor regelinvoer, die zelfs van toepassing zijn op bestanden die zijn gemaakt met later gevonden regels.

Makepp ondersteunt alle gebruikelijke shell-jokertekens ("*", "?" en "[]"). Het heeft ook een
jokerteken "**" dat overeenkomt met een willekeurig aantal tussenliggende mappen. (Dit idee was
gestolen van zsh.) "**/*.c" komt bijvoorbeeld overeen met alle .c bestanden in de gehele bron
boom. "objects/**/*.o" komt overeen met alle .o bestanden die zich ergens in de
subdirectory objecten of een van zijn submappen of een van hun submappen. De
Het jokerteken "**" volgt op geen enkel niveau zachte links naar mappen, en dat zal ook niet gebeuren
proberen mappen binnen te gaan die bestaan ​​maar niet kunnen worden gelezen. Ook bestanden en
mappen die bestaan ​​maar niet kunnen worden gelezen, worden niet geretourneerd door "$(wildcard )".

Draad Functies
voorvoegsel toevoegen voorvoegsel, woorden
Voegt de voorvoegselreeks toe aan elk van de woorden. Dit is meestal voor GNU-makelij
compatibiliteit; met behulp van uitbreiding in rc-stijl kan dit op een beter leesbare manier worden gedaan
soortgelijk:

MODULES := abcd
X_OLD_STYLE := $(addprefix $(OBJDIR)/, $(addsuffix .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # Is dat niet gemakkelijker te lezen?

voegt achtervoegsel toe achtervoegsel, woorden
Voegt de achtervoegselreeks toe aan elk van de woorden. Dit is meestal voor GNU-makelij
compatibiliteit; met behulp van uitbreiding in rc-stijl kan dit op een beter leesbare manier worden gedaan
soortgelijk:

X_OLD_STYLE := $(toevoegingsachtervoegsel .o, $(MODULES))
X_NEW_STYLE := $(MODULES).o

Bellen variabele[, woorden]...
De functie "oproep" is uniek omdat deze kan worden gebruikt om te beschouwen variabele een
geparametriseerde functie. U kunt er een complexe expressie aan toewijzen variabele en gebruiken
"call" om de inhoud ervan uit te breiden naar verschillende waarden die zijn geparametriseerd door woorden later. In
andere make-systemen, een variabele die voornamelijk wordt gebruikt om via uit te breiden
"bellen", heet a macro.

Tijdens het uitbreiden van de macro worden de tijdelijke variabelen weergegeven $1, $2, "..." verwijs naar de
argumenten gegeven aan "call" tijdens het aanroepen ervan. De variabele $0 zal worden uitgebreid naar
de naam van de macro (bijv variabele) die "oproep" breidt zich momenteel uit.

Er is geen limiet, met hoeveel argumenten een macro kan worden "aangeroepen" of met hoeveel
parameters die een macro mag verwachten. Als u meer argumenten doorgeeft aan "call" als macro
nodig zijn, zullen alle overschrijdingsargumenten terzijde worden geschoven. Als je minder argumenten doorgeeft dan a
macro verwachten, vallen alle overschrijdende parameters samen in de lege string.

Eerst een eenvoudig voorbeeld:

rest = $(woordenlijst 2, $(woorden $(1)),$(1))
lijst = ABCDE
maareerst := $(call rest,$(list))

Hier zal de variabele "$(butfirst)" de lijst "BCDE" bevatten.

En nu een complexer voorbeeld om te laten zien wat mogelijk is:

rest = $(woordenlijst 2,$(woorden $(1)),${1})
mijnkaart = $(if $2,$(aanroep $1,$(eerste woord $2)) $(aanroep $0,$1,$(aanroep rest,$2)))
hoofdletter = ${makeperl lc("$1")}

UCWORDS = AL DEZE WOORDEN ZIJN IN HOOFDLETTERS
DCWORDS := $(bel mijnkaart,kleine letters,$(UCWORDS))

Nu bevat "$(DCWORDS)" "al deze woorden zijn hoofdletters". Overigens: het maakt niet uit
verschil, of we toegang krijgen tot de argumenten via $1, "${1}" or "$(1)" binnen een macro.

U kunt de variabele direct gebruiken alsof het een functie is, als die er niet is
functie van die naam. Dit wordt intern omgezet naar "bellen", deze dus
gelijkwaardig:

discussie = De $0 werd $1 $2.
direct = $(discussie en,argument)
aangeroepen = $(oproep discussie,een,argument)

Het lijkt misschien discutabel of "$[call]" ook de macro's "$[]" moet uitbreiden
expressies, of dat een functie altijd hetzelfde moet doen, ongeacht de manier waarop
wordt genoemd. Voor dit laatste is gekozen, omdat dit bij een normale make-syntaxis het geval zou zijn
onmogelijk om "$[1], $[2]..." in een variabele te krijgen (ze zouden door niets vervangen worden,
voordat de toewijzing zelfs maar plaatsvindt.) Als u dus een macro heeft voor het definiëren van a
regel, wil je dat expressies als "$(output)" zichtbaar zijn wanneer de regel wordt geparseerd, dus
je moet ze beschermen tegen "call":

definieer mijnregel
$ 2: $ 1
mijnopdracht $$(invoer) -o $$(uitvoer)
einde
$[mijnregel mijninvoer,mijnuitvoer]

filter patronen, woorden
Retourneert alle woorden in de lijst die overeenkomen met de patronen. Patronen kunnen eenvoudigweg anders zijn
woorden of jokertekens voor bestandsnamen (dwz "*", "?" en "[az]" worden herkend), of ze kunnen
een teken "%" hebben, wat betekent dat het op dat punt met elke tekenreeks moet overeenkomen (hetzelfde als "*").

uitfilteren patronen, woorden
Retourneert alle woorden in de lijst die niet overeenkomen met de patronen. Patronen kunnen dat gewoon zijn
andere woorden of jokertekens voor de bestandsnaam (dwz "*", "?" en "[az]" worden herkend), of
ze kunnen een teken "%" hebben, wat betekent dat ze op dat punt met elke tekenreeks overeenkomen (hetzelfde als
"*").

Bijvoorbeeld:

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

zal alles zetten .o bestanden die bestaan ​​of kunnen worden gebouwd, behalve bestanden die beginnen met proef_,
in libproductie.a.

vindreeks vind, in
Retourneren vinden, als het een subtekenreeks is van in.

eerste woord woorden
Geef het eerste woord terug.

kaart woorden, perlcode
makemap woorden, perlcode
Hetzelfde geldt voor de kaart van Perl perlcode beurtelings naar elk woord en retourneert de
resultaten. De eerste variant is gewone Perl-code, terwijl de tweede variant eerst passeert
de perlcode via variabele-uitbreiding in Make-stijl. In beide zijn de woorden uitgebreid
gevallen.

De woorden zijn in $_ en worden geretourneerd tenzij u $_ ongedaan maakt. Dit is bedoeld voor
wijzigingen die niet gemakkelijk door "patsubst" kunnen worden afgehandeld. Alleen de eerste komma is een scheidingsteken,
alle andere worden beschouwd als onderdeel van de perlcode.

# Wissel van woord. Dubbele parens, om parens toe te staan ​​in perlcode, of gebruik ${}:
X = $((kaart $(WAARDEN), s/(.+)-(.+)/$2-$1/))
# Je kunt make-expressies gebruiken, maar dan moet je $$ gebruiken voor Perl $:
Y = $(makemap $(VALUES), tr/$(OLDCHARS)/$(NEWCHARS)/ of $$_ = 'mislukt')
# Je kunt kandidaten elimineren:
Y = $(kaart $(VALUES), undef $_ if /no_good/)

mee woorden1, woorden2
Maak een paarsgewijze verbinding van de eerste woorden en de tweede woorden.

patsubst patroon, plaatsvervanger, woorden
Voert een vervanging uit voor elk woord in de woordenlijst. Een teken "%" komt overeen met elk teken
snaar. Dit kan het beste worden geïllustreerd met een voorbeeld:

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

neemt elk bestand in C_SOURCES en retourneert de naam van een objectbestand in object_dir.
Soms is het beknopter om een ​​vervangingsreferentie te gebruiken, bijvoorbeeld het bovenstaande zou kunnen
zijn geschreven als

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

sorteren word1 word2 word3 ...
Sorteert de woorden in lexicale volgorde en verwijdert duplicaten.

strip snaar
Verwijdert voorloop- en volgspaties uit de tekenreeks en vervangt elke interne spatie
reeks van een of meer witruimtetekens met één spatie. Dus: "$(strip ab
c)" resulteert in "abc".

subst van,naar,tekst
Voert een tekstuele vervanging uit op de tekst: elke keer dat from voorkomt, wordt vervangen
door naar. Het resultaat wordt vervangen door de functieaanroep. Bijvoorbeeld,

$(subst ee,EE,voeten op straat)

vervangt de string "fEEt op de strEEt".

woord n, tekst
Retourneert de ne woord van tekst. De legitieme waarden van n begin vanaf 1 aan het begin
of achteruit vanaf -1 aan het einde. Als n is groter dan het aantal woorden in tekst
waarde is leeg.

woordenlijst indexlijst, woorden
woordenlijst eersteindex, laatsteindex, woorden
In het eerste formulier levert u een lijst met indices op (geteld vanaf 1 aan het begin of tot aan het begin).
achteruit vanaf -1 aan het einde) om de gewenste woorden te selecteren. In de tweede vorm jij
specificeer het bereik van woorden dat u wilt retourneren.

woorden tekst
Retourneert het aantal woorden in tekst.

Diversen Functies
foreach var,lijst,tekst
De eerste twee argumenten, var en lijst, worden uitgebreid voordat er iets anders wordt gedaan; opmerking
dat het laatste argument, de tekst, niet tegelijkertijd wordt uitgebreid. Vervolgens voor elk woord van
de uitgebreide waarde van list, de variabele die wordt genoemd door de uitgebreide waarde van var wordt ingesteld
dat woord en de tekst wordt uitgevouwen. Vermoedelijk bevat de tekst verwijzingen naar die variabele,
dus de uitbreiding zal elke keer anders zijn.

Dit eenvoudige voorbeeld stelt de variabele in bestanden naar de lijst met alle bestanden in het
mappen in de lijst dirs:

map := abcd
bestanden := $(foreach dir,$(dirs),$(wildcard $(dir)/*))

De tekst hier is "$(wildcard $(dir)/*)". De eerste herhaling vindt de waarde "a" voor dir,
het levert dus hetzelfde resultaat op als "$(wildcard a/*)"; de tweede herhaling produceert
het resultaat van "$(wildcard b/*)"; en de derde, die van "$(wildcard c/*)".

Dit voorbeeld heeft hetzelfde resultaat (behalve de instelling "dirs") als het volgende voorbeeld:

bestanden := $(wildcard a/* b/* c/* d/*)

Wanneer tekst ingewikkeld is, kunt u de leesbaarheid verbeteren door deze een naam te geven, met een
extra variabele:

find_files = $(wildcard $(dir)/*)
map := abcd
bestanden := $(foreach map,$(dirs),$(find_files))

Hier gebruiken we op deze manier de variabele find_files. We gebruiken gewone "=" om a te definiëren
recursief uitbreidende variabele, zodat de waarde ervan een daadwerkelijke functieaanroep naar bevat
opnieuw worden uitgebreid onder de controle van foreach; een eenvoudigweg uitgebreide variabele zou niet werken,
aangezien wildcard slechts één keer zou worden aangeroepen op het moment dat find_files worden gedefinieerd.

Opmerking: verwar dit niet met de speciale variabele "$(foreach)".

info tekst
waarschuwing tekst
fout tekst
Uitvoertekst die niets retourneert. De eerste gaat naar STDOUT, de tweede naar STDERR,
de derde breekt bovendien de verwerking af.

voorbouw doelen
maken doelen
Geeft het argument woordelijk terug, maar bouwt eerst alle vermelde bestanden op. Dit is nuttig
wanneer een bepaald bestand nodig is bij het evalueren van een make-expressie. Dit gebeurt meestal
wanneer je een build hebt waarbij de set betrokken bestanden door een of andere shell wordt berekend
commando's. Bijvoorbeeld,

bestandslijst:
# shell-opdrachten om een ​​lijst met bestanden te berekenen die in het programma moeten worden geplaatst

mijn_programma: $(&cat $(vooraf samengestelde bestandslijst))

Als u de lijst in meer dan één regel nodig heeft, is het efficiënter om een
maximaal één keer uitbreiden variabele:

bestandslijst ;= $(&cat $(vooraf samengestelde bestandslijst))

mijn_programma1: oa $(file_list)

mijn_programma2: bo $(file_list)

Als u in plaats daarvan alleen "$(&cat file_list)" specificeerde, dan zou makepp niet forceren
file_list om up-to-date te zijn voordat het de shell-opdracht uitvoert. "$(prebuild )" gebruiken
is de beste manier om dit probleem op te lossen. Je zou in de verleiding kunnen komen om andere dingen te proberen, zoals
deze:

mijn_programma: bestandslijst $(&cat bestandslijst)

maar dit zal niet werken omdat "$(&cat file_list)" wordt geëvalueerd voordat makepp dit probeert
bouw "bestandslijst".

alleen_phony_targets namen
Retourneert alleen de namen in de lijst die valse doelen zijn van een bepaalde regel (ofwel
expliciete of patroonregels). U kunt jokertekens opgeven (inclusief makepp's special
jokerteken, "**") in de bestandsnamen. (Zie de functie "$(wildcard)" voor meer details.
Dit kan worden gebruikt voor het groeperen van doelen, bijvoorbeeld:

$(neptests): $(only_phony_targets */**/tests)

herkomst variabele
Gegeven de naam van een variabele, vertelt u waar de waarde vandaan komt.

perl perlcode
maakperl perlcode
Evalueert perlcode in een blok en retourneert het resultaat. De eerste variant is gewoon Perl
code, terwijl de tweede variant eerst de perlcode doorgeeft via de Make-style variabele
uitbreiding.

Houd er rekening mee dat, zoals bij alle functies, het gebruikte functiescheidingsteken mogelijk niet daarin voorkomt
de perlcode buiten de strings met enkele of dubbele aanhalingstekens. Maar je kunt het verdubbelen zoals in
het laatste voorbeeld:

VA = 1
VAR1 = ${perl ($VAR + 1) * 3}
VAR2 = $(perl do { $VAR *= 3; retourneert $VAR + 1 } als $VAR)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # één Make var en één Perl var
VAR = $((perl als( ... ) { ... }))

onecht woorden
Geeft aan dat de lijst met woorden feitelijk valse doelen zijn, en retourneert de lijst met
doelen. Het is bedoeld om als volgt te worden gebruikt:

$(nep allemaal): mijn_programma

$(nepschoon):
&rm -f *.o mijn_programma

Je kunt ook een of meer doelwitten als nep verklaren met een regel als deze, waar dan ook
jouw makefile:

.PHONY: allemaal schoon

print tekst
Voert de tekst uit en retourneert deze. Dit is vooral handig voor het debuggen, als dat niet het geval is
begrijpen waarom vervanging van variabelen het resultaat heeft dat het doet. Bijvoorbeeld,

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

zal het resultaat van de "patsubst" -oproep afdrukken.

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

zal het laatste argument voor de "patsubst" -aanroep afdrukken.

schelp shell-commando
Retourneert de uitvoer van het gegeven shell-commando, waarbij nieuwe regels worden vervangen door spaties.

Houd er rekening mee dat, zoals bij alle functies, het gebruikte functiescheidingsteken mogelijk niet daarin voorkomt
het shell-commando buiten strings met enkele of dubbele aanhalingstekens. Maar je kunt het verdubbelen
zoals in het tweede voorbeeld:

date = $(shell date) # beter: $(perl scalaire lokale tijd)
VAR = ${{shell f() { echo hallo; }; F}}

xargs commando,argumenten[,achtervoegsel[,lengte]]
Retourneert een door nieuwe regels gescheiden lijst met opdrachten die elk beginnen met de opgegeven opdracht
commando, en eindig met zoveel mogelijk elementen van de lijst zonder er overheen te gaan
lengte (standaard 1000) tekens.

Het doel hiervan is om te voorkomen dat de limiet voor de opdrachtlengte op uw systeem wordt overschreden.
Als er bijvoorbeeld veel gegenereerde bestanden zijn, wilt u waarschijnlijk uw
clean target (wat je niet zou moeten hebben, omdat "makeppclean" efficiënter is).
zie er ongeveer zo uit:

$(nepschoon):
$(xargs $(RM), $(only_targets **/*))

Dit heeft ook als neveneffect dat er geen enkel commando wordt gegenereerd als de lijst
blijkt leeg te zijn. Maar in dit geval zou het beter zijn om de ingebouwde &rm,
omdat de argumenten voor de ingebouwde opdrachten alleen worden beperkt door het geheugen van Perl:

$(nepschoon):
&rm -f $(only_targets **/*)

Als er een derde argument is opgegeven, wordt dit gebruikt om elke opdracht na te fixeren. Dit is
handig voor het specificeren van redirectors, bijvoorbeeld (hoewel ook hier &echo zou helpen):

manifest:
&rm -f $@
&raak $@ aan
$(xargs echo, $(only_nontargets **/*), >> $@)

Een deel van deze documentatie is gebaseerd op de GNU-make-documentatie.

Houd er rekening mee dat als een functie wordt aangeroepen tijdens de makefile-initialisatie, bijvoorbeeld de
uitbreiding van exportvariabelen, fout- of waarschuwingsberichten rapporteren regelnummer 0.

Gebruik makepp_functions online met behulp van onworks.net-services