makepp_variables - Online in de cloud

PROGRAMMA:

NAAM

makepp_variables -- Variabelen gebruiken in makepp

PRODUCTBESCHRIJVING

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
AFLAGS,
NET ZO, C: cc,
CFLAGS,
"gewijzigde_afhankelijkheden",
gewijzigde_ingangen,
CURDIR,
CXX,
CXXVLAGS, D: "afhankelijkheden",
"afhankelijkheid", F: F77,
FC,
"voorzien", I: invoer,
ingangen, L: LD,
LEX,
LIBTOOL, M: MAKEN,
MAAK CMDDOELEN,
MAAKVLAGGEN,
MAKEINFO,
MAKEPP_DEBUG,
MAAKPFLAGS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_submappen",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_aaneenschakeling",
MAKEPP_VERSION, O: "uitvoer",
"uitgangen", P: PERL,
PWD, R: MRI,
WORTEL, S: SCHELP,
"gesorteerde_afhankelijkheden",
gesorteerde_ingangen,
"stang", T: doelwit,
doelen, V: VPATH, Y: YACC

Makefiles gebruiken doorgaans op veel plaatsen variabelen. Een belangrijke reden om te gebruiken
variabelen is om ervoor te zorgen dat informatie op slechts één plaats in de makefile staat, dus
dat als het verandert, er geen gevaar bestaat dat de twee kopieën van de informatie eruit komen
synchroniseren.

Variabelenamen zijn hoofdlettergevoelig. In theorie kunnen er vele namen van variabelen worden gemaakt
karakters, maar makepp zal het waarschijnlijk niet kunnen groken als je iets anders doet dan
alfanumerieke tekens, "_" en "-".

Elke makefile heeft zijn eigen set variabelen, en het instellen van een variabele in één makefile zal dat ook doen
hebben geen effect op de waarde ervan in een andere makefile. Als u variabelen wilt instellen
veel makefiles, de beste manier om dit te doen is om ze allemaal gemeenschappelijke definities te laten bevatten
bestand (zie de include-instructie) of gebruik "globale" variabelen.

Veranderlijk Toewijzing
Een variabele kan op verschillende manieren een waarde aannemen:

· Er kan een variabele worden ingesteld in een makefile. Er zijn een aantal verschillende manieren om te doen
dit; zie hieronder.

· De waarde van een variabele kan als volgt op de opdrachtregel worden opgegeven:

makepp CFLAGS=-O2 mijn_programma

Als er meer dan één makefile is geladen, wordt de CFLAGS-variabele doorgegeven aan alle
makefiles. Variabelen die op de opdrachtregel zijn ingesteld, overschrijven automatisch elke instelling van
de variabele in een van de makefiles.

Als het ooit nodig is, moet de makefile op zijn beurt de opdrachtregelinstellingen expliciet overschrijven.
De bedoeling is niet om te negeren wat de gebruiker vraagt, maar eerder om het te wijzigen.
De "override" modifier kan voorafgaan aan elke toewijzingsverklaring. Maar in het geval van
trefwoorden, de volgorde is belangrijk, vandaar de override-variant
altijd hieronder weergegeven. De "override"-modifier is alleen van toepassing op toewijzingen waar het
is aanwezig en heeft geen invloed op latere toewijzingen aan de variabele.

· Als een variabele in de omgeving is ingesteld, kan ernaar worden verwezen als een makepp-variabele.
Gewoonlijk overschrijven toewijzingen aan variabelen in een makefile de instellingen van de
omgeving, maar u kunt dit wijzigen door de "-e" of "--environment-overrides"
opdrachtregeloptie.

Variabelen worden toegewezen met een van de verschillende toewijzingsuitdrukkingen, zoals deze

X = 1
MODULES := abcd
CC ?= gcc
CFLAGS += -Muur
definieer VAR
var lijn 1
var lijn 2
einddef
export PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = info te zien in alle makefiles

Voorafgaande en volgende witruimte rond waarden wordt altijd verwijderd.

De verschillende toewijzingsoperatoren hebben enigszins verschillende betekenissen.

Eenvoudig toewijzing exploitanten

=
VARIABEL = tekenreeks
overschrijven VARIABELE = tekstreeks

Dit is de gebruikelijke toewijzingsverklaring die alle implementaties van make-ondersteuning bieden. De
uitdrukking aan de rechterkant wordt pas geëvalueerd als de waarde van "$(VARIABLE)" is
daadwerkelijk ergens gebruikt. Dus als je het volgende doet:

X = 1
J = $(X)
X = 2

Dan zal "$(Y)" verderop in de makefile resulteren in "2".

Over het algemeen wilt u meestal ":=" (zie hieronder) gebruiken in plaats van "=" omdat het
zorgt voor een meer voorspelbare evaluatie van variabelen. Er zijn echter momenten waarop je het nodig hebt
om de variabele evaluatie uit te stellen. En als je een makefile schrijft, moet dat ook zo zijn
achterwaarts compatibel met een andere versie van make dan GNU make, dan heb je nee
keuze: je mag alleen "=" gebruiken.

:=
VARIABEL := expr
overschrijven VARIABELE := expr

Dit is hetzelfde als "VARIABLE = expr" behalve dat de rechterkant wordt geëvalueerd
eens en voor altijd op het moment van de opdracht. Dus als

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

dan zal "$(Y)" verderop in de makefile resulteren in "1" omdat dat is wat "$(X)" was
wanneer "$(Y)" werd gedefinieerd.

;=
VARIABEL ;= expr
overschrijf VARIABELE ;= expr

Dit is hetzelfde als "VARIABLE := expr" behalve dat de rechterkant wordt geëvalueerd
alleen op het moment van het eerste gebruik en daarna onthouden. Dit is handig voor duur
commando's, die altijd dezelfde waarde retourneren, maar die u niet wanneer wilt uitvoeren
niet-gerelateerde doelen bouwen:

VAR1 ;= $(perl dure berekeningen)
VAR2 ;= $(shell extern commando)

Merk op dat oude makefiles hier meestal ":=" zullen gebruiken, om dit in ieder geval maar één keer te doen.
Maar met deze operator kun je het zelfs niet doen, als je dat momenteel niet doet
de waarde nodig. Voor waarden die in verschillende mappen identiek zijn, kan dat
optimaliseer dit verder met "globaal", hieronder besproken.

Dit is echter niet bedoeld als een slimme manier om de volgorde van evaluatie af te dwingen. Als een
variabele die op deze manier is gedefinieerd, omvat de waarde van een andere variabele en die andere
heeft een doelspecifieke waarde en de eerste uitbreiding is voor dat doel, daarna de
doelspecifieke waarde blijft ook voor alle andere contexten gelden. Dit is een fout en
wordt hopelijk in de toekomst opgelost.

+=
VARIABEL += expr
overschrijven VARIABELE += expr

Voegt de tekenreeks toe aan de vorige inhoud van de variabele, gescheiden door een spatie. Als
de variabele was eerder toegewezen met ":=", daarna wordt de rechterkant geëvalueerd
voor het toevoegen.

&=
VARIABEL &= expr
overschrijf VARIABELE &= expr

Plaatst de tekenreeks vóór de vorige inhoud van de variabele, gescheiden door een spatie.
Als de variabele eerder was toegewezen met ":=", dan is de rechterkant dat ook
geëvalueerd alvorens toe te voegen.

Een manier om bijvoorbeeld te garanderen dat "CFLAGS", wat de gebruiker verder ook invoert,
begint altijd met "-Wall" zijn deze twee regels:

CFLAGS = -O2 # Mogelijk overschreven op de opdrachtregel
override CFLAGS &= -Wall # Onvoorwaardelijk voorafgegaan

In oude makefiles moest je meestal zoiets doen, wat de zijkant had
effect van het forceren van het type naar ":=" om eindeloze recursie te voorkomen:

VARIABEL := expr $(VARIABEL)

?=
VARIABEL ?= expr
override VARIABLE ?= expr # Nutteloos, maar legaal

Stelt de waarde van de variabele in, maar alleen als de variabele niet eerder in is opgegeven
de makefile, op de opdrachtregel of in de omgeving. Bovenstaande opdracht is
precies gelijk aan

ifndef VARIABEL
VARIABEL = expr
endif

!=
VARIABEL != shell-commando
overschrijf VARIABELE != shell-opdracht

Voert de shell-opdracht uit en stelt de variabele in om de standaarduitvoer van de opdracht te bevatten.
Dit is precies gelijk aan

VARIABEL := $(shell-commando)

Multilijn variabelen

De instructie "define" is het multiline-equivalent van de eenvoudige instructies hierboven. De
operator achter de variabele is optioneel. Als het ontbreekt, is het gelijk aan "definieer VARIABELE
=". De operatoren "&=" en "+=" zijn hier iets anders, omdat ze dit aan elkaar lijmen
de oude waarde met een nieuwe regel in plaats van een spatie. Er mag niets anders zijn dan a
commentaar na de instructie, dwz de waarde begint op de volgende regel.

definieer VARIABEL :=
eerste regel met de waarde van de variabele
tweede regel met de waarde van de variabele
derde regel met de waarde van de variabele
einde

overschrijf definieer VARIABELE
...
einddef

Sleutelwoorden voor "definiëren" kunnen combinaties zijn van "exporteren" of "globaal" en
"overschrijven".

Als u de waarde van een variabele nodig hebt om nieuwe regels te bevatten, moet u de instructie "define" gebruiken als
weergegeven (of u kunt de waarde rechtstreeks in Perl toekennen). ("endef" werd gekozen voor
compatibiliteit met GNU make. U kunt ook "enddef" gebruiken.) Dit is vooral handig voor
"ingeblikte commandoreeksen", bijvoorbeeld zoiets als dit:

definieer COMPILE_C_PROGRAM
@&echo "$(invoer) samenstellen"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(invoer) -o $(uitvoer)
einde

Vervolgens kunt u deze variabele met meerdere regels in verschillende regels gebruiken, zoals deze:

%.o: %.c
$(COMPILE_C_PROGRAM)

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

Merk op dat u vaak hetzelfde effect kunt bereiken door een puntkomma te gebruiken in plaats van een nieuwe regel,
omdat de shell dat ook interpreteert als een opdrachtscheidingsteken. Bijvoorbeeld,

COMPILE_C_PROGRAM = @echo "$(invoer) compileren"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(invoer) -o $(uitvoer)

zal hetzelfde effect hebben, behalve dat de puntkomma Perl dwingt om het door te geven aan de shell,
in plaats van de opdracht direct en efficiënter uit te voeren. Je moet ook elk plaatsen
ingebouwd op een eigen regel, wat betekent dat je moet overschakelen naar de externe echo in de
puntkomma geval.

Er is één specialiteit bij het uitbreiden binnen "define", dwz "define X :=" of op a
variabele die al ":=", "define X &=" en "define X +=" was. In dit geval de
"$(shell command ...)" of ingebouwde "$(&command ...)" worden niet omgezet in nieuwe regels
ruimten.

Exporteren variabelen naar subprocessen

VAR exporteren ...
exporteren VAR = waarde
overschrijf export VAR += waarde

Het eerste formulier markeert de gegeven variabelen voor export naar subprocessen, met welke waarde dan ook
de variabele heeft dan. Het tweede formulier, dat alleen van toepassing is op één variabele, komt daar bovenop
kent meteen een waarde toe. Alle toewijzingsvarianten zijn toegestaan.

Delen variabelen over maakbestanden

wereldwijde VAR ...
globale VAR = waarde
overschrijf de globale VAR &= waarde

De eerste vorm markeert de gegeven variabelen als globaal voor alle makefiles. Als een van hen
al een waarde had, wordt die waarde verplaatst van de variabele makefile local naar de global
een. Als echter op het moment dat deze verklaring wordt gezien, andere makefiles al een
waarde voor een van hen, dan zullen die makefiles de globale niet zien.

De tweede vorm, die alleen van toepassing is op één variabele, kent bovendien een waarderecht toe
weg. Alle toewijzingsvarianten zijn toegestaan. Merk op dat ":=" meteen zal uitbreiden
naar de waarden in de lokale makefile. Integendeel "=" variabelen zullen uitbreiden naar de
waarden op het punt van gebruik.

Globale variabelen kunnen lastig zijn om mee om te gaan, omdat makepp makefiles in elk bestand kan laden
volgorde, als de behoefte zich voordoet om een ​​doel te bouwen waarvoor geen regel of makefiles is geladen.
Om deze reden is het aan te raden om een RootMakepp-bestand en om expliciet alles te laden
anderen die de variabele wijzigen of gebruiken met "load-makefile".

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

Houd er ook rekening mee dat uw project op een dag samen met andere projecten kan worden gebouwd. Voor deze
reden dat het wordt aanbevolen om de projectnaam altijd onderdeel te maken van de naam van een globale variabele.

Doelspecifiek opdrachten

doel: VARIABELE = tekenreeks
doel: VARIABELE := tekenreeks
doel: overschrijf VARIABELE += tekenreeks

Stelt een doelspecifieke waarde van de variabele in. Er is een doelspecifieke waarde van kracht Slechts
in een actie die het gegeven doel produceert. Dit wordt voornamelijk gebruikt voor zaken als
deze:

CLAGS := -O2

mijn_prog: bestand1.o bestand2.o speciaal_bestand.o

speciaal_bestand.o: CFLAGS:= -g

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

Wat hier gebeurt, is dat alle ".c"-bestanden worden gecompileerd met optimalisatie ("-O2") behalve
"special_file.c", dat is gecompileerd in foutopsporingsmodus ("-g"). Dit is een handige manier om
specificeer verschillende compilatie-opties voor slechts een paar bestanden.

Doelspecifieke variabeletoewijzingen zoals deze zijn alleen van toepassing op de acties van de regel; zij
zijn niet van kracht bij het evalueren van de doelen of de afhankelijkheden van een regel. Als een regel
meer dan één doel heeft, worden doelspecifieke variabeletoewijzingen alleen overgenomen van de
eerste doel. Merk ook op dat de doelspecifieke variabelen van makepp enigszins verschillen
van GNU make's in die zin dat ze alleen van toepassing zijn op de regel voor het ene genoemde bestand, en niet op
een van zijn voorgangers.

Uitbreiding met jokertekens wordt uitgevoerd op het doelwit, dus u kunt zoiets als dit doen:

test_*.o: CFLAGS += -DTEST

Voor compatibiliteit met GNU make kan "%" worden gebruikt in plaats van "*".

Veranderlijk Vervanging
De variabele vervangingsregels van Makepp zijn vergelijkbaar met die van andere merken, maar enigszins
krachtiger. Zoals bij alle merken vertegenwoordigen "$(CC)" of "${CC}" beide de waarde van de
variabele CC. Als je een letterlijk dollarteken nodig hebt, plaats dan een dubbel dollarteken ($$), zoals
deze:

doel: dep1 dep2 dep3 dep4
&rm -f $(uitvoer)
voor bestand in $(invoer); do cat $$bestand >> $(uitvoer); klaar

Daarnaast heeft makepp een "$[VARIABLE]" syntaxis, die hetzelfde doet als de andere
twee, maar voordat makepp iets anders gromt. Hierdoor kan het worden gebruikt voor volledige regels
en/of voorwaarden:

definieer bracket_rule =
ifdef SOME_VAR
haakje:
&echo dit is een regel -o $(uitvoer)
endif
einddef

$[beugel_regel]

rc-stijl vervanging

Makepp gebruikt standaard vervanging in rc-stijl (zo genoemd omdat het werd gepionierd door de
rc-schaal). Dit wordt het beste geïllustreerd aan de hand van een voorbeeld:

MODULES = abcd

mijnlib.a: module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(afhankelijkheden) -o $(doel)

Het voorvoegsel "module_dir/" wordt toegevoegd aan elk woord in MODULES en het achtervoegsel ".o" is
toegevoegd aan elk woord.

U kunt ook vervanging in rc-stijl gebruiken zonder zelfs maar de lijst met woorden in a te zetten
variabel; de syntaxis is "$(woord1 woord2)". Let op de ruimte tussen de haakjes en de
eerste woord. Het bovenstaande voorbeeld had dus kunnen worden geschreven als:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(afhankelijkheden) -o $(doel)

Een variabele geeft alleen vervanging in rc-stijl als er meer dan één woord in zit.
Met één woord is het als traditioneel maken. Helaas, als de variabele leeg is, is er een
conflict. Traditionele merken breiden het eenvoudig uit naar de lege string. Maar als je eraan denkt
als een lijst, zou je willen dat "-I$(DIRLIST)" verdwijnt, niet om een ​​eenzame "-I" te geven. De
oplossing is om het in een lijst te stoppen die begint met een spatie: "-I$( $(DIRLIST))" geeft je
precies zoveel opties als er woorden in de lijst staan.

Als u verschillende variabelen in hetzelfde woord plaatst die zich uitbreiden tot arrays van woorden, rc-stijl
substitutie neemt eigenlijk het cartesiaanse product, dus je kunt zoiets doen als
jij wil:

DIRS = s1 s2
MODULES = abc
ACHTERVOEGSELS = .o .c
BESTANDEN := $(DIRS)/$(MODULES)$(SUFFIXEN)

en FILES zal de string bevatten

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

Naast witruimte stopt de rc-stijlvervanging bij elk aanhalingsteken, elk rond, gekruld of vierkant
haakjes, en elk van ", : ; = # @". Merk op dat dit verrassend kan zijn en opnieuw nodig is
een expliciete lijst. Stel dat u in alle mappen naar headers wilt zoeken met jokertekens
beginnend met een hoofdletter:

SLECHT := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
GOED := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Als vervanging in rc-stijl in de weg zit, of als je een voorsprong of een achterstand nodig hebt
witruimte in uw make-variabelen, dan kunt u rc-achtige vervanging uitschakelen door in te stellen
de variabele "makepp_simple_concatenation=1". U kunt het op de opdracht wereldwijd uitschakelen
regel of als een omgevingsvariabele. Of per makefile door de variabele in te stellen
uw makefile. U moet dit doen in de buurt van de bovenkant van de makefile, anders kunt u tegen
grappige situaties waarin vervanging in rc-stijl wordt gebruikt voor sommige evaluaties en niet voor andere.
(Alle uitdrukkingen die vóór de toewijzing zijn geëvalueerd, gebruiken vervangingen in rc-stijl, en alle
expressies geëvalueerd nadat wil niet. Sinds de tijd van evaluatie van uitdrukkingen in
makefiles is gecompliceerd en niet altijd duidelijk uit de volgorde van de statements in de
makefile, is het het beste om "makepp_simple_concatenation" zo vroeg mogelijk in te stellen.) U kunt
stel het zelfs in voor slechts één doel:

doel: makepp_simple_concatenation = 1
doelwit:
&echo voor_eerste$(LIJST)na_laatste -o $(uitvoer)

Omdat "$[VARIABLE]" eerder wordt geëvalueerd dan "$(VARIABLE)", combineert u de twee in rc-
substitutie geeft niet het resultaat dat u mag verwachten, tenzij u het expliciet verpakt
lijst:

EEN = ab
N = 1 2
SLECHT := $(A)$[N]
GOED := $(A)$( $[N])

De laatste regels worden gelezen als

SLECHT := $(A)1 2 # a1 b1 2
GOED := $(A)$( 1 2) # a1 a2 b1 b2

Vervanging Referenties

Een vervangingsreferentie heeft de vorm "$(VAR:A=B)", waarbij A een overeenkomend patroon is en B
een patroon om het mee te vervangen. Vervangingsreferenties zijn een afkorting voor de
"patsubst"-functie. Bijvoorbeeld:

source_files = ac bc cc dc
object_files = $(bronbestanden:%.c=%.o)

zal "$(object_files)" instellen op "ao bo co do". De "%" is een speciaal teken dat overeenkomt
elke willekeurige string. Als zowel A als B beginnen met "%", een veel voorkomend geval bij het vervangen
achtervoegsels, ze kunnen worden weggelaten:

object_bestanden = $(bronbestanden:.c=.o)
object_files = $(source_files:c=o) # idem, omdat . is niet bijzonder

Witte ruimte in variabelen

Als u de witruimte in een variabele wilt controleren, moet u rc-style (momenteel) uitschakelen
vervanging (door "makepp_simple_concatenation=1" in te stellen) en gebruik dan een syntaxis zoals deze:

nul =
T = -o $(nul)

of, met een lege evaluatie:

T = -o $()

Wanneer u dit doet, bevat de variabele "T" "-o" gevolgd door een spatie.

Dit soort techniek om met witruimte om te gaan wordt niet aanbevolen. Als je variabelen nodig hebt
in je makefile spaties moet bevatten, moet je serieus nadenken over wat je doet.
Als u met spaties moet omgaan, is het meestal veel beter om Perl-code in uw
makefile om ervoor te zorgen (met behulp van de instructies "perl_begin" of "sub"), of om het te verwerken
in shell-statements in de acties van regels.

Deze gevallen doen zich meestal voor wanneer mensen proberen dezelfde regels voor verschillende doeleinden te gebruiken
architecturen die geen typische Unix-opdrachtsyntaxis gebruiken. Bijvoorbeeld, soms ziet men
dit soort dingen in makefiles:

ifeq ($(ARCH),vreemdarch)
O := /UITVOER=
anders
nul :=
O := -o $(null)
endif

%.o: %.c
$(COMPILER) $(invoer) $(O)$(uitvoer)

Je kunt dit doen met makepp als je dat echt wilt, maar je zult waarschijnlijk merken dat jouw
makefiles zijn aanzienlijk leesbaarder als u een minder ingewikkelde variabele heeft
vervanging, bijv.

ifeq ($(ARCH),vreemdarch)
%.o: %.c
$(WEIRD_COMPILER) $(invoer) /OUTPUT=$(uitvoer)
anders
%.o: %.c
$(CC) -c $(invoer) -o $(uitvoer)
endif

Witruimte is nooit toegestaan ​​in namen van variabelen, alleen in hun waarden. Dit is anders
van sommige make-implementaties.

Automatisch Variabelen
Automatische variabelen zijn variabelen die verschillende waarden aannemen, afhankelijk van welke regel
ze worden geëvalueerd. Makepp ondersteunt de meeste automatische variabelen die andere
versies van gebruik maken. Bovendien heeft het voor de meeste van hen minder cryptische, langere namen
die u in plaats daarvan kunt gebruiken. (Voor verouderde makefiles die deze namen herdefiniëren, is de
definitie in de makefile overschrijft de standaardbetekenis. Als je bijvoorbeeld zegt
"target = abc" in uw makefile, dan zal "$(target)" altijd uitbreiden naar "abc", en zal niet
langer gelijk zijn aan $@.)

Het volgende is een volledige lijst van alle automatische variabelen die makepp ondersteunt:

uitgang
doel
$@ Het doel van de huidige regel. Eigenlijk, aangezien makepp meerdere doelen ondersteunt voor
elke regel, dit is de eerste doel. Bijvoorbeeld in de volgende regel

y.tab.c y.tab.h : parser.y
$(YACC) -o $(uitvoer) $(YFLAGS) $(invoer)

"$(output)" zal de waarde bevatten y.tab.c. Omdat deze magische variabelen in feite zijn
functies, kunt u ook een index als argument doorgeven. Dit telt vanaf 1 of terug
vanaf 1. Dus "$(output 2)" of "$(output -1)" zal de waarde bevatten y.tab.h.

Hoewel alle drie de vormen van deze variabele dezelfde waarde hebben, is er een verschil in
interpretatie voor multitarget-regels. Als je de ouderwetse cryptische naam $@ gebruikt,
makepp zal dat interpreteren als een regelset in oude stijl, in plaats van een moderne regel die
produceert al die doelen in één keer:

ab: # echt: elk een regel voor a en b
raak $@ aan

cd: # error: mpp klaagt dat dit niet heeft gebouwd d
raak $(uitvoer) aan

uitgangen
doelen
Alle doelen van de huidige regel. Hetzelfde als "$(target)", tenzij er meer dan één is
doel. In het bovenstaande voorbeeld is "$(outputs)" y.tab.c y.tab.h. U kunt een
indexlijst, dus "$(outputs 2 1)" wordt y.tab.h y.tab.c.

afhankelijkheid
invoer
$< De eerste expliciete afhankelijkheid van de regel. Bijvoorbeeld in deze regel

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

"$(invoer)" is de naam van het .c bestand, ongeacht wat .h bestanden makepp
ontdekt. Als u meer dan één afhankelijkheid opgeeft, kunt u deze ophalen door een
index: "$(invoer $(INDEX))" is de INDEXe afhankelijkheid.

afhankelijkheden
ingangen
$^ Alle expliciete afhankelijkheden van het doel, niet inbegrepen .h bestanden ontdekt door
makepp_scanning voor omvat.

Bijvoorbeeld in de regel

mijnprog.o : *.o
$(CC) $(CFLAGS) $(invoer) -o $(uitvoer)

"$(inputs)" zijn alle .o-bestanden in de map. U kunt alleen degene kiezen die u kiest
willen door een indexlijst door te geven. Als u expliciet verschillende soorten bestanden opgeeft,
je kunt ze kiezen zoals in "$(inputs 2 3 4)" (maar met een jokerteken is dit niet te
veelbelovend).

gesorteerd_afhankelijkheden
gesorteerd_invoeren
$+ Alle afhankelijkheden van het doel, in gesorteerde volgorde, met duplicaten verwijderd.
Gelijk aan "$(sorteer $(invoer))".

gewijzigde_afhankelijkheden
gewijzigde_ingangen
$? De afhankelijkheden van het doel die zijn veranderd. Dit omvat alleen expliciet
afhankelijkheden (dwz degene die u opsomt in de makefile), niet impliciet ontdekt
afhankelijkheden van scannen (zoals .h-bestanden).

Dit wordt vaak gebruikt in commando's zoals deze:

libmine.a: $(MODULES): build_check negeer_actie
$(AR) ru $@ $?

d.w.z, ar wordt verteld om alleen die modules te vervangen die zijn gewijzigd. (Merk op
"ignore_action" build-controleregel. Als u dit niet opgeeft, forceert makepp het
actie die moet worden uitgevoerd wanneer deze verandert. Als er geen afhankelijkheden zijn gewijzigd, wordt het
actiereeks zal "ar ru libmine.a" zijn, wat waarschijnlijk anders is dan wat het was
laatste keer dat u het uitvoerde, dus zonder "ignore_action" zal makepp het uitvoeren. In deze
geval is het onschadelijk, maar met andere commando's kan het een probleem vormen. Zien
makepp_build_check voor details over "ignore_action".)

Het bouwen van archieven op deze manier is geen goed idee, omdat het je builds minder zal maken
betrouwbaar. Het probleem hiermee is dat als u het archief opbouwt, u er een verwijdert
de modules uit de lijst met MODULES, de modules staan ​​nog steeds in het archief en
makepp

stengel
$* De stam in een patroonregel (dwz ongeacht de '%' die overeenkomt). Alternatief, als dit
is geen patroonregel, retourneert de bestandsnaam zonder de extensie (d.w.z. het is
gelijk aan "$(basisnaam $(invoer))".

Dit is meestal voor achterwaartse compatibiliteit. Bijvoorbeeld in oude versies van make the
enige manier om het te vertellen hoe het moet worden gecompileerd .c bestand in de overeenkomstige .o bestand was als
deze:

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

Dit is een waardeloze manier om de regel te schrijven. Het is veel duidelijker om GNU-make-stijl te gebruiken
patroonregels, zoals deze:

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

foreach
De huidige bestandsnaam uit de "foreach"-clausule. "Foreach"-clausules worden zelden gebruikt,
maar ze zijn de meest algemene soort patroonregel die makepp ondersteunt. Voor
voorbeeld,

#
# Bouw .c-bestanden met een soort speciale preprocessor:
#
%.c : %.k
$(preprocessor) $(invoer) > $(uitvoer)

#
# Compileer .c-bestanden naar .o-bestanden:
#
%.o: %.c
$(CC) $(CFLAGS) -c $(invoer) -o $(uitvoer)

#
# Speciale alternatieve compilatievlaggen voor .c-bestanden die zijn afgeleid
# uit .k-bestanden:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(invoer) -o $(uitvoer)

Zie de documentatie over de foreach-clausule in regels voor meer details en voorbeelden.

$/ Dit is in wezen een constante, ofwel "/", of op native Windows "\". Je hebt het nodig, als
u wilt een programma draagbaar starten, bijvoorbeeld een programma dat u in de huidige map hebt gebouwd:

mijnuitvoer:
.$/mijnprog >$(uitvoer)

Voor bestandsnamen die als argument worden doorgegeven is het niet zo noodzakelijk aangezien Windows Unix aankan
syntaxis daar.

Keuze Variabelen
U kunt deze op alle hierboven beschreven manieren (tenzij anders vermeld) wijzigen
het gedrag van makepp. Standaard zijn ze allemaal ongedefinieerd.

MAKEPP_DEBUG
Als u dit exporteert met een echte waarde voordat u makepp aanroept, krijgt u meer foutopsporing
informatie. Dit is de "RULE_SOURCE" van bestanden die zijn gebouwd terwijl dit van kracht is onder
makeppinfo, mppi en details over het uitbreiden van variabelen en het matchen van regels onder
makepplog, mppl. Dit zal je ook laten zien of makepp geen geheugen meer heeft of vastloopt,
omdat het eindeloos dezelfde variabelen uitbreidt:

A = $A # uitgestelde evaluatie, behoefte aan :=
B = $C
C = $B

MAKEPP_LN_CP
Zie de opmerking onder &ln.

makepp_percent_subdirs
Stel dit in op een echte waarde (zoals 1) om "%" in doelen of afhankelijkheden overeen te laten komen
in meer dan één directory.

makepp_require_phony
Stel dit in op een echte waarde (zoals 1) om impliciete onechtheid te voorkomen (dwz als een regel
slaagt zonder zijn doelwit te produceren). Deze variabele moet standaard waar zijn, to
gebroken afhankelijkheidsketens voorkomen, maar dat zou de achterwaartse compatibiliteit met
slordige makefiles.

makepp_signature_C_flat
Dit is een optie voor handtekening C. Stel dit in op een echte waarde (zoals 1) om uw te behandelen
bronnen als afgevlakt, dwz alle nieuwe regels (behalve rond preprocessor-statements) zijn
behandeld als witruimte en "#line"-richtlijnen worden genegeerd.

makepp_simple_aaneenschakeling
Stel dit in op een echte waarde (zoals 1) om "rc-stijl vervanging" te voorkomen.

PERL
U kunt dit instellen op de exacte perl die u gebruikt om de scripts in de makepp uit te voeren
suite en exporteer het. Dit kan helpen om subscripts met dezelfde perl uit te voeren. Dit is
vooral handig voor de testsuite, de installatie en voor recursieve builds.

VPATH
Het instellen van deze variabele op een bepaalde waarde roept impliciet "vpath % waarde" op.

Vooraf gedefinieerde Variabelen
Makepp definieert vooraf een aantal variabelen, die u kunt overschrijven:

AR Standaard: "ar".

AFLAGS
Standaard: "rv".

AS Standaard: "als".

CC Standaard: De eerste gevonden onder "gcc", "egcc", "pgcc", "c89" of "cc", of op Windows
bovendien "cl" of "bcc32".

CLAGS
Standaard: Als "$(CC)" een GNU-compiler "-g -Wall" is, als het een van de twee Windows
compilers niets, anders "-g".

CURDIR
De map waarin de huidige Makefile zich bevindt.

CXX Standaard: De eerste gevonden onder "g++", "c++", "pg++", "cxx", "C" "C" of "aCC", of op
Windows bovendien "cl" of "bcc32".

CXXVLAGS
Standaard: Als "$(CXX)" een GNU-compiler "-g -Wall" is, als het een van de twee Windows
compilers niets, anders "-g".

F77 Standaard: De eerste gevonden onder "f77", "g77" of "fort77".

FC Standaard: "$(F77)".

LD Standaard: "ld".

LEX Standaard: De eerste gevonden onder "lex" of "flex".

LIBTOOL
Standaard: "libtool".

MAAK
Deze variabele heeft twee verschillende waarden, afhankelijk van de aanwezigheid of niet van
"--traditionele-recursieve-make". Makepp herkent wanneer deze variabele wordt gebruikt en
schakelt sommige functies uit, zelfs voordat de recursie daadwerkelijk plaatsvindt. Dit kan zijn
ongewenst terwijl u het geleidelijk aan het elimineren bent, dus converteer de oproepen eerst naar een
makepp-specifieke "$((MAKE))", waarmee functies niet worden uitgeschakeld. Je moet het niet instellen
omdat dat ons slimme recursiewerk doorbreekt.

MAAKCMDDOELEN
Deze variabele is ingesteld maar wordt niet gebruikt door makepp. U kunt het alleen vragen om iets te doen als
er werd om een ​​bepaald doel gevraagd.

Standaard: Welke expliciete doelen de gebruiker (of een recursieve aanroep) ook heeft opgegeven.
Leeg bij impliciet bouwen van standaarddoel.

ifneq $(filter speciaal doel, $(MAKECMDGOALS))
# special-target is een van de huidige expliciete targets
anders ifeq $(MAKECMDGOALS)
# geen expliciete doelen
endif

MAKEFLAGS (geëxporteerd)
De standaard opties waarmee makepp werd aangeroepen. Degenen die een enkele letter hebben
vorm worden aan het begin gecombineerd zonder een leidende "-" (de hemel weet waarom gmake koos
om de "-") te laten vallen.

MAAKINFO
Standaard: "maakinfo".

MAKEPPFLAGS (geëxporteerd)
Dit is ingesteld op dezelfde waarde als MAKEFLAGS, maar alleen als deze variabele aanwezig is in
makepps omgeving.

_MAKEPPFLAGS (geëxporteerd)
De makepp-specifieke opties die nodig zijn voor POSIX/gmake-compatibiliteit, waarmee makepp
heette. Deze bevinden zich in een afzonderlijke variabele, zodat een legacy makefile niet kapot kan gaan
compatibiliteit door MAKEFLAGS uit te schakelen. Dit is alleen ingesteld met
"--traditionele-recursieve-make".

MAKEPP_VERSION
De versie van makepp waarmee u werkt. Als het een bètaversie is, heeft deze een
koppelteken gevolgd door JJMMDD plus wat meer interne gegevens. U kunt dit gebruiken voor "ifdef"
om makepp-specifieke constructies te verbergen voor andere merken.

Standaard: Dezelfde waarde weergegeven door "makepp --version"

PWD Een alias voor "CURDIR".

RM Standaard: "rm-f". Dit is bedoeld voor verouderde Makefiles. Voor nieuwe bij voorkeur gebruiken
het ingebouwde &rm-commando rechtstreeks. Als je een valse opschoonregel wilt schrijven, kijk dan naar
in plaats daarvan de opdracht "makeppclean -r".

ROOT
Het relatieve pad naar de hoofdmap van uw build-systeem, dwz de map verderop
waarvoor je een "RootMakeppfile(.mk)" hebt. Als je er geen hebt, is deze variabele dat wel
leeg.

SHELL
Deze variabele wordt alleen gerespecteerd als u deze "exporteert". In dat geval is het de Shell
die wordt gebruikt om niet-ingebouwde acties uit te voeren met een speciaal teken erin (plain
degenen die rechtstreeks worden uitgevoerd). Op Windows Strawberry of ActiveState Perl, als je dat hebt
een Unix-achtige Shell, moet u in plaats daarvan uw SHELL-variabele instellen op een waarde die eindigt op "sh"
of "sh.exe" vaardigheden makepp bellen.

Standaard: De eerste gevonden tussen "/usr/xpg4/bin/sh" (bijv. Solaris) of "/sbin/xpg4/sh"
(bijv. Reliant Unix) of "/ Bin / sh".

YACC
Standaard: De eerste gevonden onder "bison -y" of "yacc".

Variabelen en Perl
Variabele waarden worden opgeslagen als gewone Perl-scalairen, zodat u er rechtstreeks toegang toe hebt
Perl-code als u er ingewikkelde manipulaties mee moet doen; zie makepp_extending
voor meer info.

Toegang tot globale variabelen vanuit Perl wordt bereikt door ze vooraf te laten gaan met de "Mpp::global"
pakket. In feite elke variabele die nog niet aanwezig is in de huidige makefile en die u
toewijzen aan in dit pakket zal vanaf dat moment globaal zijn, alsof u zojuist de
"globale" verklaring ervoor.

Deze directe toegang is echter foutgevoelig! De gebruiker heeft deze variabelen mogelijk overschreven
op de opdrachtregel of via de omgeving. Een andere makefile is hiervoor geladen
men kan de variabele globaal of doelspecifiek hebben gemaakt. In deze gevallen zou u dat niet doen
de waarde van de variabele vinden, of bij het toewijzen ervan de eigenschap ervan wegnemen
(equivalent aan een "override" modifier, behalve doelspecificaties.)

Met directe toegang omzeil je ook de uitbreiding van deze variabelen, als ze van het type zijn
"=" of ";=". Speciale variabelen zoals "$(CC)" beginnen als functies, totdat ze dat zijn
toegewezen aan. Dus in veel gevallen zie je de waarde niet.

Om deze redenen is het beter makepp de juiste waarde te laten bepalen. U kunt de
"makeperl"-variant, waarin de variabele is geëvalueerd voordat de Perl-code wordt opgehaald
geïnterpreteerd:

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

Als u een variabele in makefile perl-blokken nodig heeft, wordt dit bereikt via de Perl-variabele
$makefile als volgt:

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

Functies krijgen altijd het makefile-object doorgegeven als het tweede argument $_[1]:

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

Commando's worden verondersteld te worden aangeroepen binnen een regelactie, waar het object makefile zich bevindt
toegankelijk via "$Mpp::Subs::rule->{MAKEFILE}":

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

Gebruik makepp_variables online met behulp van onworks.net-services