makepp_variables - Online în cloud

PROGRAM:

NUME

makepp_variables -- Cum se utilizează variabilele în makepp

DESCRIERE

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAGS,
LA FEL DE, C: DC,
CFLAGS,
„dependențe_schimbate”,
intrări_modificate,
CURDIR,
CXX,
CXXFLAGS, D: „dependențe”,
"dependenţă", F: F77,
FC,
"pentru fiecare", I: intrare,
intrări, L: LD,
LEX,
LIBTOOL, M: FACE,
FACEȚI CMDGOALS,
MAKEFLAGS,
MAKEINFO,
MAKEPP_DEBUG,
MAKEPPFLAGS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "ieșire",
"ieșiri", P: PERL,
PWD, R: RMN,
RĂDĂCINĂ, S: COAJĂ,
"dependențe_sortate",
intrări_sortate,
"tulpina", T: țintă,
obiective, V: VPATH, Y: YACC

Makefiles folosesc de obicei variabile în multe locuri. Un motiv important pentru utilizare
variabile este de a se asigura că informațiile sunt conținute într-un singur loc din makefile, deci
că dacă se schimbă, nu există pericolul ca cele două copii ale informației să iasă din el
sincronizare

Numele variabilelor țin cont de majuscule. În teorie, numele variabilelor pot fi făcute din mai multe
personaje, dar makepp probabil că nu va putea să-l găsească dacă faci altceva decât
caractere alfanumerice, „_” și „-”.

Fiecare makefile are propriul său set de variabile, iar setarea unei variabile într-un makefile va avea loc
nu au niciun efect asupra valorii sale în niciun alt makefile. Dacă doriți să setați variabile
multe makefiles, cel mai bun mod de a face acest lucru este ca fiecare dintre ele să includă definiții comune
fișier (consultați instrucțiunea include) sau utilizați variabile „globale”.

Variabil Cesiune
O variabilă poate lua o valoare în mai multe moduri diferite:

· O variabilă poate fi setată în interiorul unui makefile. Există o serie de moduri diferite de a face
acest; Vezi mai jos.

· Valoarea unei variabile poate fi specificată pe linia de comandă, astfel:

makepp CFLAGS=-O2 programul_meu

Dacă sunt încărcate mai multe makefile, variabila CFLAGS este propagată la toate
makefiles. Variabilele setate pe linia de comandă anulează automat orice setare a
variabila din oricare dintre fișierele make.

Dacă este vreodată nevoie, makefile-ul trebuie, la rândul său, să suprascrie în mod explicit setările liniei de comandă.
Intenția nu este de a ignora ceea ce solicită utilizatorul, ci mai degrabă o modalitate de a-l modifica.
Modificatorul „override” poate precede orice instrucțiune de atribuire. Dar în cazul
declarații de cuvinte cheie, ordinea este importantă, motiv pentru care varianta de override este
întotdeauna prezentate mai jos. Modificatorul „înlocuire” se aplică numai oricăror sarcini în care acesta
este prezent și nu influențează atribuirile ulterioare ale variabilei.

· Dacă o variabilă este setată în mediu, aceasta poate fi referită ca variabilă makepp.
De obicei, atribuirile variabilelor din interiorul unui makefile înlocuiesc setările din
mediu, dar puteți modifica acest lucru folosind „-e” sau „--environment-overrides”
opțiune linie de comandă.

Variabilele sunt alocate cu una dintre mai multe expresii de atribuire, ca aceasta

X = 1
MODULE := abcd
CC ?= gcc
CFLAGS += -Perete
definiți VAR
var linia 1
var linia 2
enddef
export PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = informații care trebuie văzute în toate fișierele make

Spațiile albe de început și de urmă din jurul valorilor sunt întotdeauna eliminate.

Diferiții operatori de atribuire au semnificații oarecum diferite.

simplu cesiune Operatorii

=
VARIABLE = șir de text
override VARIABLE = șir de text

Aceasta este declarația obișnuită de atribuire pe care o acceptă toate implementările. The
expresia din partea dreaptă nu este evaluată până când valoarea „$(VARIABLE)” nu este
folosit de fapt undeva. Astfel, dacă faci următoarele:

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

Apoi „$(Y)” mai târziu în makefile va fi evaluat la „2”.

În general, de obicei doriți să utilizați „:=" (vezi mai jos) în loc de „=", deoarece aceasta
oferă o evaluare mai previzibilă a variabilelor. Cu toate acestea, există momente când aveți nevoie
pentru a amâna evaluarea variabilei. De asemenea, dacă scrieți un makefile, acesta trebuie să fie
compatibil cu o altă versiune de make decât GNU make, atunci nu aveți
alegere: puteți utiliza doar „=".

:=
VARIABILĂ := expr
suprascrie VARIABILĂ := expr

Acesta este același cu „VARIABLE = expr”, cu excepția faptului că partea dreaptă este evaluată
o dată pentru totdeauna la momentul atribuirii. Astfel dacă

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

apoi „$(Y)” mai târziu în makefile va fi evaluat la „1”, deoarece asta a fost „$(X)”
când a fost definit „$(Y)”.

;=
VARIABIL ;= expr
suprascrie VARIABILĂ ;= expr

Acesta este același cu „VARIABLE := expr”, cu excepția faptului că partea dreaptă este evaluată
numai în momentul primei utilizări și apoi reținut. Acest lucru este util pentru scump
comenzi, care returnează întotdeauna aceeași valoare, dar pe care nu doriți să le executați când
construirea de obiective necorelate:

VAR1 ;= $(calcule scumpe perl)
VAR2 ;= $(comanda externă shell)

Rețineți că fișierele make vechi vor folosi de obicei „:=" aici, pentru a face acest lucru cel puțin o singură dată.
Dar cu acest operator puteți chiar să nu o faceți, dacă în prezent nu o faceți
nevoie de valoare. Pentru valori care sunt identice în mai multe directoare, puteți
optimizați acest lucru în continuare cu „global”, discutat mai jos.

Cu toate acestea, aceasta nu este concepută ca o modalitate inteligentă de a forța ordinea evaluării. În cazul în care o
variabila definită astfel include valoarea unei alte variabile și a celeilalte variabile
are o valoare specifică țintei, iar prima extindere este pentru acea țintă, apoi
valoarea specifică țintă va rămâne și pentru toate celelalte contexte. Acesta este un bug și
sperăm că va fi remediat în viitor.

+=
VARIABILA += expr
suprascrie VARIABILĂ += expr

Adaugă șirul la conținutul anterior al variabilei, separat de un spațiu. Dacă
variabila a fost atribuită anterior cu „:=", apoi partea dreaptă este evaluată
înainte de a adăuga.

&=
VARIABILĂ &= expr
suprascrie VARIABLE &= expr

Afișează șirul la conținutul anterior al variabilei, separat de un spațiu.
Dacă variabila a fost atribuită anterior cu „:=", atunci partea dreaptă este
evaluat înainte de anexare.

De exemplu, o modalitate de a garanta că „CFLAGS”, orice altceva ar putea introduce utilizatorul,
începe întotdeauna cu „-Wall” sunt următoarele două rânduri:

CFLAGS = -O2 # Posibil suprascris pe linia de comandă
suprascrie CFLAGS &= -Wall # Adăugată necondiționat

În fișierele make vechi, de obicei, trebuia să faci ceva de genul acesta, care avea o parte
efectul de a forța tipul la „:=" pentru a preveni recursiunea fără sfârșit:

VARIABILĂ := expr $(VARIABILĂ)

?=
VARIABILĂ ?= expr
override VARIABLE ?= expr # Inutil, dar legal

Setează valoarea variabilei, dar numai dacă variabila nu este specificată mai devreme
makefile, pe linia de comandă sau în mediu. Misiunea de mai sus este
exact echivalent cu

ifndef VARIABIL
VARIABIL = expr
endif

!=
VARIABLE != comandă shell
override VARIABLE != comanda shell

Rulează comanda shell și setează variabila să conțină rezultatul standard al comenzii.
Acest lucru este exact echivalent cu

VARIABILĂ := $(comandă shell)

Multilinie variabile

Declarația „define” este echivalentul pe mai multe linii al declarațiilor simple de mai sus. The
operatorul după variabilă este opțional. Dacă lipsește, este echivalent cu „definiți VARIABIL
=". Operatorii "&=" și "+=" sunt ușor diferiți aici, prin faptul că lipesc acest lucru de
valoarea veche cu o linie nouă, mai degrabă decât un spațiu. Nu trebuie să existe nimic în afară de a
comentează după declarație, adică valoarea începe pe linia următoare.

defineste VARIABILA :=
prima linie a valorii variabilei
a doua linie a valorii variabilei
a treia linie a valorii variabilei
endef

override define VARIABLE
...
enddef

Cuvintele cheie înainte de „definire” pot fi combinații dintre „export” sau „global” și
"trece peste".

Dacă aveți nevoie ca valoarea unei variabile să conțină linii noi, trebuie să utilizați instrucțiunea „define” as
afișat (sau puteți atribui valoarea direct în Perl). („endef” a fost ales pentru
compatibilitate cu GNU make. Puteți folosi, de asemenea, „enddef”.) Acest lucru este util în primul rând pentru
„secvențe de comandă conservate”, de exemplu, ceva de genul acesta:

definiți COMPILE_C_PROGRAM
@&echo „Compilarea $(intrare)”
@$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDE) -c $(intrare) -o $(ieșire)
endef

Apoi puteți utiliza această variabilă cu mai multe linii în mai multe reguli, ca aceasta:

%.o : %.c
$(COMPILE_C_PROGRAM)

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

Rețineți că puteți obține adesea același efect folosind un punct și virgulă în loc de o linie nouă,
deoarece shell-ul interpretează asta și ca un delimetru de comandă. De exemplu,

COMPILE_C_PROGRAM = @echo "Compilarea $(intrare)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDE) -c $(intrare) -o $(ieșire)

va avea același efect, cu excepția faptului că punctul și virgulă forțează Perl să-l treacă în shell,
în loc să execute comanda direct și mai eficient. De asemenea, trebuie să puneți fiecare
încorporat pe o linie proprie, ceea ce înseamnă că trebuie să comutați la ecoul extern în
caz punct și virgulă.

Există o specialitate atunci când se extinde în „define”, adică „define X :=" sau pe a
variabilă care era deja „:=", „define X &=" și „define X +=". În acest caz,
„$(comandă shell...)” sau „$(&comandă...)” încorporat nu primesc linii noi transformate în
spații.

Exportarea variabile la subprocese

export VAR...
export VAR = valoare
înlocuiți valoarea exportului VAR +=

Prima formă marchează variabilele date pentru export în subprocese, cu orice valoare
variabila are atunci. A doua formă, care se aplică doar unei variabile, în plus
atribuie imediat o valoare. Sunt permise toate variantele de atribuire.

Partajarea variabile peste makefiles

VAR global...
VAR global = valoare
suprascrieți valoarea globală VAR &=

Prima formă marchează variabilele date ca fiind globale pentru toate fișierele make. Dacă vreuna dintre ele
avea deja o valoare, acea valoare este mutată din variabila locală makefile la globală
unu. Totuși, dacă, în momentul în care este văzută această declarație, orice alte fișiere make aveau deja un
valoare pentru oricare dintre ele, atunci acele fișiere make nu vor vedea pe cel global.

A doua formă, care se aplică doar unei variabile, atribuie suplimentar un drept de valoare
departe. Sunt permise toate variantele de atribuire. Rețineți că „:=" se va extinde imediat
la valorile din makefile local. Dimpotrivă, variabilele „=" se vor extinde la
valorile la punctul de utilizare.

Variabilele globale pot fi dificil de tratat, deoarece makepp poate încărca fișiere make în oricare
ordine, pe măsură ce apare necesitatea de a construi o țintă pentru care nu sunt încărcate nicio regulă sau fișiere make.
Din acest motiv se recomanda sa ai un RootMakeppfile și pentru a încărca în mod explicit toate
altele care modifică sau folosesc variabila cu „load-makefile”.

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

De asemenea, rețineți că proiectul dvs. poate fi construit într-o zi împreună cu alte proiecte. Pentru aceasta
motiv pentru care este recomandat să faceți întotdeauna numele proiectului parte din orice nume de variabilă globală.

Specific țintei misiuni

target: VARIABLE = șir
target: VARIABLE := șir
țintă: suprascrie VARIABLE += șir

Setează o valoare specifică țintei a variabilei. Este în vigoare o valoare specifică țintei afară
într-o acţiune care produce ţinta dată. Acesta este folosit în principal pentru lucruri precum
acest:

CFLAGS := -O2

my_prog: fișier1.o fișier2.o fișier_special.o

fisier_special.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(intrare) -o $(ieșire)

Ce se întâmplă aici este că toate fișierele „.c” vor fi compilate cu optimizare („-O2”) cu excepția
„special_file.c”, care este compilat în modul de depanare („-g”). Aceasta este o modalitate convenabilă de a
specificați diferite opțiuni de compilare doar pentru câteva fișiere.

Atribuțiile variabile specifice țintei ca aceasta se aplică numai acțiunilor regulii; ei
nu sunt în vigoare atunci când se evaluează obiectivele sau dependențele unei reguli. Dacă o regulă
are mai mult de o țintă, atribuirile de variabile specifice țintei sunt luate numai din
primul ţintă. De asemenea, rețineți că variabilele specifice țintei makepp sunt ușor diferite
de la GNU make's prin aceea că se aplică doar regulii pentru un singur fișier menționat, și nu și pentru
oricare dintre predecesorii săi.

Expansiunea wildcard este efectuată pe țintă, așa că puteți face ceva de genul acesta:

test_*.o : CFLAGS += -DTEST

Pentru compatibilitate cu GNU make, „%” poate fi folosit în locul „*”.

Variabil Înlocuire
Regulile de substituție variabile ale lui Makepp sunt similare cu cele ale altor mărci, dar oarecum
mai puternic. Ca în toate mărcile, „$(CC)” sau „${CC}” reprezintă ambele valoarea
variabila CC. Dacă aveți nevoie de un semn de dolar literal, puneți un semn de dolar dublu ($$), cum ar fi
acest:

tinta: dep1 dep2 dep3 dep4
&rm -f $(ieșire)
pentru fișier în $(intrari); do cat $$fișier >> $(ieșire); Terminat

În plus, makepp are o sintaxă „$[VARIABLE]”, care face același lucru ca cealaltă
doi, dar înainte ca Makepp să facă ceva altceva. Acest lucru permite utilizarea acestuia pentru reguli complete
și/sau condiționale:

definește regulă_paranteză =
ifdef SOME_VAR
paranteză:
&echo aceasta este o regulă -o $(ieșire)
endif
enddef

$[bracket_rule]

stil rc substituție

În mod implicit, makepp folosește înlocuirea în stil rc (așa numită pentru că a fost pionier de către
shell rc). Acest lucru este cel mai bine ilustrat printr-un exemplu:

MODULE = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(dependențe) -o $(țintă)

Prefixul „module_dir/” este adăugat fiecărui cuvânt din MODULE, iar sufixul „.o” este
atașat fiecărui cuvânt.

De asemenea, puteți utiliza înlocuirea în stil rc fără a pune măcar lista de cuvinte în a
variabil; sintaxa este „$( cuvânt1 cuvânt2)”. Observați spațiul dintre paranteză și
primul cuvânt. Deci exemplul de mai sus ar fi putut fi scris astfel:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dependențe) -o $(țintă)

O variabilă va oferi substituție în stil rc numai atunci când există mai mult de un cuvânt în ea.
Cu un singur cuvânt este ca o fabrica tradițională. Din păcate, când variabila este goală, există a
conflict. Măsurile tradiționale pur și simplu îl extind la șirul gol. Dar când te gândești la
ca o listă, ați dori ca „-I$(DIRLIST)” să dispară, nu să dea un „-I” singuratic. The
soluția este să o împachetați într-o listă care începe cu un spațiu: „-I$( $(DIRLIST))” vă oferă
exact la fel de multe opțiuni, câte cuvinte sunt în listă.

Dacă puneți mai multe variabile în același cuvânt care se extind la matrice de cuvinte, rc-style
substituția ia de fapt produsul cartezian, așa că poți face așa ceva dacă
tu vrei:

DIRS = s1 s2
MODULE = abc
SUFIXE = .o .c
FIȘIERE := $(DIRS)/$(MODULE)$(SUFIXE)

iar FIȘIERE va conține șirul

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

Pe lângă spațiul alb, înlocuirea în stil rc se oprește la orice citat, orice rotund, ondulat sau pătrat
paranteze și oricare dintre „, : ; = # @”. Rețineți că acest lucru poate fi surprinzător și, din nou, trebuie
o listă explicită. Să presupunem că doriți să căutați antete după caractere metalice în toate directoarele
începând cu o literă mare:

RĂU := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
BUN := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Dacă înlocuirea în stil rc vă împiedică, sau dacă trebuie să aveți început sau final
spații albe în variabilele de realizare, apoi puteți dezactiva înlocuirea în stil rc prin setare
variabila „makepp_simple_concatenation=1”. Îl puteți dezactiva global din comandă
linie sau ca variabilă de mediu. Sau pe bază de fișier creat prin setarea variabilei în
makefile-ul tău. Ar trebui să faceți acest lucru în partea de sus a fișierului make, altfel puteți întâlni
situații amuzante în care substituția în stil rc este folosită pentru unele evaluări și nu pentru altele.
(Toate expresiile evaluate înainte de atribuire vor folosi substituții în stil rc și toate
expresiile evaluate după will not. Din momentul evaluării expresiilor în
makefiles este complicat și nu întotdeauna evident din ordinea declarațiilor din
makefile, cel mai bine este să setați „makepp_simple_concatenation” cât mai devreme posibil.) Puteți
chiar și setați-o doar pentru o țintă:

țintă: makepp_simple_concatenation = 1
ţintă:
&echo before_first$(LIST)după_ultimul -o $(ieșire)

Deoarece „$[VARIABLE]” este evaluat mai devreme decât „$(VARIABLE)”, combinând cele două în rc-
înlocuirea nu va da rezultatul la care vă puteți aștepta, cu excepția cazului în care îl includeți într-un mod explicit
listă:

A = ab
N = 1 2
RĂU := $(A)$[N]
BUN := $(A)$( $[N])

Ultimele rânduri sunt citite ca

RĂU := $(A)1 2 # a1 b1 2
BINE := $(A)$( 1 2) # a1 a2 b1 b2

Înlocuire Referinte

O referință de substituție are forma „$(VAR:A=B)”, unde A este un model de potrivire și B este
un model cu care să-l înlocuiască. Referințele de înlocuire sunt o abreviere pentru
funcția „patsubst”. De exemplu:

fisiere_sursa = ac bc cc dc
obiect_fișiere = $(sursă_fișiere:%.c=%.o)

va seta „$(object_files)” la „ao bo co do”. „%” este un caracter special care se potrivește
orice șir arbitrar. Dacă atât A cât și B încep cu „%”, un caz obișnuit la înlocuire
sufixe, acestea pot fi omise:

obiect_fișiere = $(sursă_fișiere:.c=.o)
object_files = $(source_files:c=o) # la fel, deoarece . nu este special

Spatiu alb in variabile

Dacă trebuie să controlați spațiul alb dintr-o variabilă, trebuie (în prezent) să dezactivați rc-style
înlocuire (prin setarea „makepp_simple_concatenation=1”) și apoi utilizați o sintaxă ca aceasta:

nul =
T = -o $(null)

sau, cu o evaluare goală:

T = -o $()

Când faceți acest lucru, variabila „T” conține „-o” urmat de un spațiu.

Acest tip de tehnică de a gestiona spațiile albe nu este recomandată. Dacă aveți nevoie de variabile
în makefile pentru a conține spații, ar trebui să vă gândiți serios la ceea ce faceți.
Dacă trebuie să gestionați spațiile, de obicei este mult mai bine să introduceți codul Perl în dvs
makefile pentru a avea grijă de el (folosind instrucțiunile „perl_begin” sau „sub”) sau pentru a-l gestiona
în declarații shell în acțiunile regulilor.

Aceste cazuri apar de obicei atunci când oamenii încearcă să folosească aceleași reguli pentru diferite
arhitecturi care nu folosesc sintaxa tipică a comenzilor Unix. De exemplu, uneori se vede
lucruri de genul acesta în makefiles:

ifeq ($(ARCH),weirdarch)
O := /OUTPUT=
altfel
nul :=
O := -o $(null)
endif

%.o : %.c
$(COMPILATOR) $(intrare) $(O)$(ieșire)

Puteți face acest lucru cu makepp dacă doriți cu adevărat, dar probabil veți găsi că dvs
Makefile-urile sunt substanțial mai lizibile dacă aveți variabile mai puțin complicate
substituție, de exemplu,

ifeq ($(ARCH),weirdarch)
%.o : %.c
$(WEIRD_COMPILER) $(intrare) /OUTPUT=$(ieșire)
altfel
%.o : %.c
$(CC) -c $(intrare) -o $(ieșire)
endif

Spațiile albe nu sunt permise niciodată în numele variabilelor, ci doar în valorile acestora. Acest lucru este diferit
din unele realizează implementări.

Automat Variabile
Variabilele automate sunt variabile care asumă valori diferite în funcție de regulă
ele sunt evaluate în. Makepp acceptă majoritatea variabilelor automate pe care celelalte
versiuni de face use. În plus, are nume mai puțin criptice, mai lungi pentru majoritatea dintre ei
pe care îl poți folosi în schimb. (Pentru fișierele vechi care se întâmplă să redefinească aceste nume, aplicația
definiția din makefile suprascrie semnificația implicită. De exemplu, dacă spui
„target = abc” din makefile, apoi „$(target)” se va extinde întotdeauna la „abc” și nu
mai fi echivalent cu $@.)

Următoarea este o listă completă a tuturor variabilelor automate pe care makepp le acceptă:

producție
ţintă
$@ Ținta regulii curente. De fapt, deoarece makepp acceptă mai multe ținte pentru
orice regulă, aceasta este primul ţintă. De exemplu, în următoarea regulă

y.tab.c y.tab.h : parser.y
$(YACC) -o $(ieșire) $(YFLAGS) $(intrare)

„$(ieșire)” va conține valoarea y.tab.c. Deoarece aceste variabile magice sunt de fapt
funcții, puteți trece și un index ca argument. Aceasta contează de la 1 sau înapoi
de la -1. Deci „$(ieșire 2)” sau „$(ieșire -1)” va conține valoarea y.tab.h.

În timp ce toate cele trei forme ale acestei variabile au aceeași valoare, există o diferență în
interpretare pentru regulile multitarget. Dacă utilizați numele criptic în stil vechi $@,
makepp va interpreta asta ca un set de reguli în stil vechi, mai degrabă decât o regulă modernă care
produce toate acele ținte dintr-o singură mișcare:

ab: # într-adevăr: câte o regulă pentru a și b
atinge $@

cd: # eroare: mpp se plânge că acest lucru nu a fost construit d
atinge $(ieșire)

iesiri
obiective
Toate țintele regulii actuale. La fel ca „$(țintă)”, cu excepția cazului în care există mai multe
ţintă. În exemplul de mai sus, „$(ieșiri)” va fi y.tab.c y.tab.h. Poți trece un
lista de indexuri, deci „$(ieșiri 2 1)” va fi y.tab.h y.tab.c.

dependenţă
intrare
$< Prima dependență explicită a regulii. De exemplu, în această regulă

%.o : %.c
$(CC) $(CFLAGS) -c $(intrare) -o $(ieșire)

„$(input)” va fi numele .c dosar, indiferent de ce .h fișiere makepp
descoperă. Dacă specificați mai multe dependențe, le puteți obține prin transmiterea unui
index: „$(input $(INDEX))” este a doua dependență INDEX.

dependențe
intrări
$^ Toate dependențele explicite ale țintei, fără a include .h fișiere descoperite de
makepp_scanning pentru include.

De exemplu, în regulă

myprog.o : *.o
$(CC) $(CFLAGS) $(intrări) -o $(ieșire)

„$(inputs)” vor fi toate fișierele .o din director. Poți să-i alegi doar pe cei pe care tu
doresc prin trecerea unei liste de index. Dacă specificați în mod explicit diferite tipuri de fișiere,
le puteți alege ca în „$(inputs 2 3 4)” (dar cu un wildcard acest lucru nu este prea
promițătoare).

dependențe_sortate
intrări_sortate
$+ Toate dependențele țintei, în ordine sortată, cu duplicatele eliminate.
Echivalent cu „$(sortare $(intrari))”.

dependențe_schimbate
intrări_schimbate
$? Dependențe ale țintei care s-au schimbat. Aceasta include doar explicit
dependențe (adică cele enumerate în fișierul make), nedescoperite implicit
dependențe de la scanare (cum ar fi fișierele .h).

Acesta este folosit în mod obișnuit în comenzi ca aceasta:

libmine.a : $(MODULE) : build_check ignore_action
$(AR) ru $@ $?

și anume, ar i se spune să înlocuiască numai acele module care s-au schimbat. (Rețineți că
„ignore_action” regulă de verificare a construirii. Dacă nu specificați acest lucru, makepp va forța
acțiune care trebuie executată ori de câte ori se schimbă. Dacă nicio dependență nu s-a schimbat, aplicația
șirul de acțiuni va fi „ar ru libmine.a”, care este probabil diferit de ceea ce a fost
ultima dată când l-ați rulat, deci fără „ignore_action” makepp îl va executa. In acest
caz, este inofensiv, dar cu alte comenzi, ar putea fi o problemă. Vedea
makepp_build_check pentru detalii despre „ignore_action”.)

Construirea de arhive ca aceasta nu este o idee bună, deoarece vă va reduce construcțiile
de încredere. Problema cu aceasta este că, dacă construiți arhiva, atunci eliminați una dintre
modulele din lista de MODULE, modulele vor fi în continuare în arhivă și
makepp

stăvili
$* Tulpina dintr-o regulă de tipar (adică, oricare ar fi potrivit „%”). Alternativ, dacă aceasta
nu este o regulă de tipar, returnează numele fișierului fără extensie (adică este
echivalent cu „$(basename $(input))”.

Acest lucru este mai ales pentru compatibilitatea cu versiunea anterioară. De exemplu, în versiunile vechi ale make the
singurul mod de a-i spune cum să compilați oricare .c fișier în fișierul corespunzător .o dosarul a fost ca
acest:

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

Acesta este un mod prost de a scrie regula. Este mult mai clar să folosești stilul GNU-make
reguli de tipar, ca aceasta:

%.o : %.c
$(CC) $(CFLAGS) -c $(intrare) -o $(ieșire)

pentru fiecare
Numele actual al fișierului din clauza „foreach”. clauzele „foreach” sunt rar folosite,
dar sunt cel mai general tip de regulă de tipar pe care makepp o acceptă. Pentru
exemplu,

#
# Construiți fișiere .c cu un fel de preprocesor special:
#
%.c: %.k
$(preprocesor) $(intrare) > $(ieșire)

#
# Compilați fișiere .c în fișiere .o:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(intrare) -o $(ieșire)

#
# Steaguri de compilare alternative speciale pentru fișierele .c care sunt derivate
# din fișierele .k:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(intrare) -o $(ieșire)

Consultați documentația privind fiecare clauză din reguli pentru mai multe detalii și exemple.

$/ Aceasta este în esență o constantă, fie „/”, fie pe Windows nativ „\”. Ai nevoie de ea, dacă
doriți să porniți un program portabil, de exemplu unul pe care l-ați creat în directorul curent:

ieșirea mea:
.$/myprog >$(ieșire)

Pentru numele de fișiere transmise ca argumente nu este atât de necesar, deoarece Windows poate gestiona Unix
sintaxa acolo.

Opțiune Variabile
Le puteți seta în toate modurile explicate mai sus (cu excepția cazului în care este specificat altfel) pentru a le modifica
comportamentul lui makepp. În mod implicit, toate sunt nedefinite.

MAKEPP_DEBUG
Dacă exportați acest lucru cu o valoare adevărată înainte de a apela makepp, obțineți mai multă depanare
info. Aceasta este „RULE_SOURCE” fișierelor create în timp ce aceasta este în vigoare sub
makeppinfo, mppi și detalii despre extinderea variabilelor și potrivirea regulilor sub
makepplog, mppl. Acest lucru vă va arăta și dacă makepp rămâne fără memorie sau se blochează,
deoarece extinde la nesfârșit aceleași variabile:

A = $A # evaluare amânată, nevoie de :=
B = $C
C = $B

MAKEPP_LN_CP
Vezi nota de sub &ln.

makepp_percent_subdirs
Setați această valoare la o valoare adevărată (cum ar fi 1) pentru ca „%” în ținte sau dependențe să se potrivească
în mai mult de un director.

makepp_require_phony
Setați această valoare la o valoare adevărată (cum ar fi 1) pentru a preveni falsitatea implicită (adică dacă o regulă
reușește fără a-și produce ținta). Această variabilă ar trebui să fie adevărată în mod implicit, la
preveni lanțurile de dependență rupte, dar asta ar rupe compatibilitatea cu
makefile neglijenți.

makepp_signature_C_flat
Aceasta este o opțiune pentru semnătura C. Setați-o la o valoare adevărată (cum ar fi 1) pentru a vă trata
sursele ca aplatizate, adică toate liniile noi (cu excepția instrucțiunilor preprocesorului) sunt
tratate ca spații albe și directivele „#line” sunt ignorate.

makepp_simple_concatenation
Setați această valoare la o valoare adevărată (cum ar fi 1) pentru a preveni „substituția în stil rc”.

PERL
Puteți seta acest lucru la perl exact pe care îl utilizați pentru a rula scripturile în makepp
suite și exportați-o. Acest lucru poate ajuta la rularea subscripturilor cu același perl. Aceasta este
util mai ales pentru suita de testare, instalare și pentru versiuni recursive.

VPATH
Setarea acestei variabile la o anumită valoare apelează implicit „vpath % value”.

Predefinit Variabile
Makepp predefinite câteva variabile, pe care le puteți suprascrie:

AR Mod implicit: „ar”.

ARFLAGS
Mod implicit: „rv”.

AS Mod implicit: "la fel de".

CC Mod implicit: Primul găsit printre „gcc”, „egcc”, „pgcc”, „c89” sau „cc”, sau pe Windows
în plus, „cl” sau „bcc32”.

CFLAGS
Mod implicit: Dacă „$(CC)” este un compilator GNU „-g -Wall”, dacă este unul dintre cele două Windows
compilatorii nimic, altfel "-g".

CURDIR
Directorul în care se află Makefile curent.

CXX Mod implicit: Primul găsit printre „g++”, „c++”, „pg++”, „cxx”, „C” „C” sau „aCC”, sau pe
Windows, în plus, „cl” sau „bcc32”.

CXXFLAGS
Mod implicit: Dacă „$(CXX)” este un compilator GNU „-g -Wall”, dacă este unul dintre cele două Windows
compilatorii nimic, altfel "-g".

F77 Mod implicit: Primul găsit printre „f77”, „g77” sau „fort77”.

FC Mod implicit: „$(F77)”.

LD Mod implicit: „ld”.

LEX Mod implicit: Primul găsit printre „lex” sau „flex”.

LIBTOOL
Mod implicit: „libtool”.

FACE
Această variabilă are două valori diferite, în funcție de prezența sau nu a
„--make-tradițional-recursiv”. Makepp recunoaște când este utilizată această variabilă și
dezactivează unele caracteristici, chiar înainte ca recursiunea să aibă loc efectiv. Acesta poate fi
nedorit în timp ce îl eliminați treptat, așa că mai întâi convertiți apelurile în a
„$((MAKE))” specific makepp, care nu va dezactiva funcțiile. Nu ar trebui să-l setați
pentru că asta distruge munca noastră de recursivitate inteligentă.

FĂCEM OBIECTIVE
Această variabilă este setată, dar nu este utilizată de makepp. Îl poți întreba pentru a face ceva numai dacă
s-a cerut o anumită țintă.

Mod implicit: Indiferent de obiectivele explicite furnizate de utilizator (sau o invocare recursivă).
Golit când se construiește implicit ținta implicită.

ifneq $(filter special-target, $(MAKECMDGOALS))
# special-target este una dintre obiectivele explicite curente
altfel dacă $(MAKECMDGOALS)
# fără ținte explicite
endif

MAKEFLAGS (exportat)
Opțiunile standard cu care a fost apelat makepp. Cele care au o singură literă
forma sunt combinate la început fără un „-” principal (cerul știe de ce a ales gmake
pentru a renunța la „-”).

MAKEINFO
Mod implicit: „facă informații”.

MAKEPPFLAGS (exportat)
Aceasta este setată la aceeași valoare ca MAKEFLAGS, dar numai dacă această variabilă este prezentă în
mediul lui makepp.

_MAKEPPFLAGS (exportat)
Opțiunile specifice makepp necesare pentru compatibilitatea POSIX/gmake, cu care makepp
a fost chemat. Acestea sunt într-o variabilă separată, astfel încât un makefile vechi nu se poate rupe
compatibilitate prin dezactivarea MAKEFLAGS. Acesta este setat doar cu
„--make-tradițional-recursiv”.

MAKEPP_VERSION
Versiunea de makepp cu care rulați. Dacă este o versiune beta, va avea un
cratima urmată de YYMMDD plus câteva date interne. Puteți folosi asta pentru „ifdef”
pentru a ascunde constructele specifice makepp de la alte mărci.

Mod implicit: Aceeași valoare afișată de „makepp --version”

PWD Un alias pentru „CURDIR”.

RM Mod implicit: "rm -f". Acest lucru este destinat pentru fișierele Makefile vechi. Pentru cele noi, utilizați de preferință
comanda încorporată &rm direct. Dacă doriți să scrieți o regulă curată falsă, uitați-vă la
în schimb comanda „makeppclean -r”.

ROOT
Calea relativă către rădăcina sistemului dvs. de construcție, adică directorul mai sus în
care aveți un „RootMakeppfile(.mk)”. Dacă nu aveți unul, această variabilă este
gol.

COAJĂ
Această variabilă este respectată doar dacă o „exportați”. În acest caz, este Shell
care este folosit pentru a executa acțiuni neconstruite cu un anumit caracter special (plain
cele fiind executate direct). Pe Windows Strawberry sau ActiveState Perl, dacă aveți
un Shell asemănător Unix, trebuie să setați variabila SHELL la o valoare care se termină în „sh”
sau „sh.exe” înainte sunând pe makepp.

Mod implicit: Prima găsită printre „/usr/xpg4/bin/sh” (de exemplu, Solaris) sau „/sbin/xpg4/sh”
(de exemplu, Reliant Unix) sau "/ Bin / sh".

YACC
Mod implicit: Primul găsit printre „bizon -y” sau „yacc”.

Variabile și Perl
Valorile variabilelor sunt stocate ca scalari Perl obișnuiți, astfel încât să le puteți accesa direct de la
Cod Perl dacă trebuie să faceți manipulări complicate cu ele; vezi makepp_extending
pentru detalii.

Accesarea variabilelor globale din Perl se realizează prin prefixarea lor cu „Mpp::global”
pachet. De fapt, orice variabilă, care nu este încă prezentă în fișierul makefile curent și pe care tu
assign to în acest pachet va fi de atunci încolo global, ca și cum tocmai ați fi emis
declarație „globală” pentru aceasta.

Acest acces direct este totuși predispus la erori! Este posibil ca utilizatorul să fi suprascris aceste variabile
pe linia de comandă sau prin mediu. Un alt makefile încărcat înainte de aceasta
este posibil ca variabila să fie globală sau specifică țintei. În aceste cazuri nu ai face-o
găsiți valoarea variabilei sau, atunci când o atribuiți, s-ar putea să-i ia proprietatea
(echivalent cu un modificator „de suprascriere”, cu excepția specificului țintei.)

Cu acces direct ocoliți și extinderea acestor variabile, dacă sunt de tip
"=" sau ";=". Variabilele speciale precum „$(CC)” încep ca funcții, până când sunt
atribuit. Deci, în multe cazuri, nu le vei vedea valoarea.

Din aceste motive, este mai bine să lăsați makepp să determine valoarea corectă. Puteți folosi
Varianta „makeperl”, în care variabila a fost evaluată înainte de a primi codul Perl
interpretat:

makeperl { $$valoare_actuală = '$(MAKEFILE_VAR)' }

Dacă aveți nevoie de o variabilă în blocurile makefile perl, aceasta se realizează prin variabila Perl
$makefile după cum urmează:

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

Funcțiile primesc întotdeauna obiectul makefile transmis ca al doilea argument $_[1]:

sub f_f { $valoare_actuală = $_[1]->variabilă_expandă( 'MAKE_VAR' ) }

Se presupune că comenzile sunt apelate în cadrul unei acțiuni de regulă, unde este obiectul makefile
accesibil prin „$Mpp::Subs::rule->{MAKEFILE}”:

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

Utilizați makepp_variables online folosind serviciile onworks.net