makepp_variables - Online w chmurze

PROGRAM:

IMIĘ

makepp_variables — Jak używać zmiennych w makepp

OPIS

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAGI,
TAK JAK, C: DC,
CFLAGI,
"zmienione_zależności",
zmienione_wejścia,
KURDYR,
XXX,
CXXFLAG, D: „zależności”,
"zależność", F: F77,
tętno,
"dla każdego", I: Wejście,
wejść, L: LD
Lex,
LIBTOOL, M: ROBIĆ,
MAKECMMDGOALS,
MAKEFLAGI,
INFO,
MAKEPP_DEBUG,
MAKEPPLAGI,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_podkatalogi",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "wyjście",
„wyjścia”, P: PERŁ,
PWD, R: rezonans magnetyczny,
ŹRÓDŁO, S: POWŁOKA,
"sortowane_zależności",
posortowane_wejścia,
"trzon", T: cel,
cele, V: VPATH, Y: YACC

Pliki Makefile zazwyczaj używają zmiennych w wielu miejscach. Jeden ważny powód używania
zmienne ma na celu zapewnienie, że informacje będą zawarte tylko w jednym miejscu w pliku makefile, tzw
że w przypadku zmiany nie ma niebezpieczeństwa, że ​​obie kopie informacji wyjdą na zewnątrz
synchronizacja

W nazwach zmiennych rozróżniana jest wielkość liter. Teoretycznie nazwy zmiennych mogą składać się z wielu
znaków, ale makepp prawdopodobnie nie będzie w stanie ich przechwycić, jeśli zrobisz cokolwiek innego niż
znaki alfanumeryczne, „_” i „-”.

Każdy plik makefile ma swój własny zestaw zmiennych i ustawienie zmiennej w jednym pliku makefile tak będzie
nie mają wpływu na jego wartość w żadnym innym pliku makefile. Jeśli chcesz mieć ustawione zmienne
wiele plików makefile, najlepszym sposobem na to jest umieszczenie każdego z nich we wspólnych definicjach
plik (zobacz instrukcję include) lub użyj zmiennych „globalnych”.

Zmienna Cesja
Zmienna może przyjmować wartość na kilka różnych sposobów:

· Zmienną można ustawić wewnątrz pliku makefile. Można to zrobić na wiele różnych sposobów
Ten; patrz poniżej.

· Wartość zmiennej można określić w wierszu poleceń w następujący sposób:

makepp CFLAGS=-O2 mój_program

Jeśli załadowanych jest więcej niż jeden plik makefile, zmienna CFLAGS jest propagowana do wszystkich
pliki makefile. Zmienne ustawione w wierszu poleceń automatycznie zastępują wszelkie ustawienia
zmienną w dowolnym pliku makefile.

Jeśli zajdzie taka potrzeba, plik makefile musi z kolei jawnie zastąpić ustawienia wiersza poleceń.
Zamiarem nie jest ignorowanie żądań użytkownika, ale raczej sposób ich modyfikacji.
Modyfikator „override” może poprzedzać dowolną instrukcję przypisania. Ale w przypadku
słowa kluczowego, kolejność jest ważna i dlatego jest nią wariant zastępujący
zawsze pokazane poniżej. Modyfikator „przesłonięcia” ma zastosowanie tylko do wszelkich przypisań, w których występuje
jest obecny i nie ma wpływu na późniejsze przypisania do zmiennej.

· Jeśli w środowisku ustawiona jest zmienna, można się do niej odwoływać jako zmienną makepp.
Zwykle przypisania do zmiennych wewnątrz pliku makefile zastępują ustawienia z pliku
środowisku, ale możesz to zmienić, używając „-e” lub „--environment-overrides”
opcja linii poleceń.

Zmiennym przypisuje się jedno z kilku wyrażeń przypisania, takich jak to

X = 1
MODUŁY := abcd
CC?= gcc
CFLAGS += -Ściana
zdefiniuj VAR
zmienna linia 1
zmienna linia 2
koniec
eksportuj PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = informacje widoczne we wszystkich plikach makefile

Początkowe i końcowe białe znaki wokół wartości są zawsze usuwane.

Różne operatory przypisania mają nieco inne znaczenie.

Prosty cesja operatorzy

=
ZMIENNA = ciąg tekstowy
zastąp ZMIENNĄ = ciąg tekstowy

Jest to zwykła instrukcja przypisania, którą obsługują wszystkie implementacje make. The
wyrażenie po prawej stronie nie jest oceniane, dopóki nie zostanie uzyskana wartość „$(VARIABLE)”.
faktycznie gdzieś używany. Zatem, jeśli wykonasz następujące czynności:

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

Następnie „$(Y)” później w pliku makefile będzie miało wartość „2”.

Ogólnie rzecz biorąc, zwykle chcesz używać „:=" (patrz poniżej) zamiast „=", ponieważ tak jest
zapewnia bardziej przewidywalną ocenę zmiennych. Są jednak chwile, kiedy tego potrzebujesz
odłożyć ocenę zmiennej. Ponadto, jeśli piszesz plik makefile, musi to być
wstecznie kompatybilny z jakąś wersją make inną niż GNU make, to nie masz
wybór: możesz użyć tylko „=".

:=
ZMIENNA := wyr
zastąp ZMIENNĄ := wyrażenie

Działa to tak samo, jak „ZMIENNA = wyrażenie”, z tą różnicą, że oceniana jest prawa strona
raz na zawsze w momencie zlecenia. Zatem jeśli

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

wtedy „$(Y)” później w pliku makefile zostanie ocenione na „1”, ponieważ właśnie to było „$(X)”
kiedy zdefiniowano „$(Y)”.

;=
ZMIENNA ;= wyrażenie
zastąp ZMIENNĄ ;= wyrażenie

Działa to tak samo, jak „ZMIENNA := wyrażenie”, z tą różnicą, że oceniana jest prawa strona
dopiero przy pierwszym użyciu i potem zapamiętany. Jest to przydatne w przypadku drogich
polecenia, które zawsze zwracają tę samą wartość, ale których nie chcesz wykonywać, kiedy
budowanie niepowiązanych celów:

VAR1 ;= $(kosztowne obliczenia w perlu)
VAR2 ;= $(polecenie zewnętrzne powłoki)

Zauważ, że stare pliki makefile zwykle używają tutaj ":=", aby zrobić to przynajmniej raz.
Ale z tym operatorem możesz nawet dodatkowo tego nie robić, jeśli obecnie tego nie robisz
potrzebuję wartości. Można to zrobić w przypadku wartości identycznych w kilku katalogach
zoptymalizuj to dalej za pomocą opcji „globalnej”, omówionej poniżej.

Jednakże nie ma to być sprytny sposób na wymuszenie kolejności oceny. Jeśli
zmienna zdefiniowana w ten sposób zawiera wartość innej zmiennej i tej innej
ma określoną wartość docelową i pierwsze rozwinięcie dotyczy tego celu, następnie
określona wartość docelowa będzie obowiązywać również we wszystkich innych kontekstach. To jest błąd i
miejmy nadzieję, że zostanie to naprawione w przyszłości.

+=
ZMIENNA += wyr
zastąp ZMIENNĄ += wyrażenie

Dołącza ciąg znaków do poprzedniej zawartości zmiennej, oddzielając go spacją. Jeśli
do zmiennej przypisano wcześniej znak „:=", wówczas oceniana jest prawa strona
przed dodaniem.

&=
ZMIENNA &= wyr
zastąp ZMIENNĄ &= wyrażenie

Dołącza ciąg do poprzedniej zawartości zmiennej, oddzielając go spacją.
Jeśli do zmiennej przypisano wcześniej znak „:=", to prawa strona jest taka
oceniane przed dodaniem.

Na przykład jeden ze sposobów zagwarantowania, że ​​„CFLAGS”, niezależnie od tego, co użytkownik umieści,
zawsze zaczyna się od „-Wall”, to są te dwie linie:

CFLAGS = -O2 # Prawdopodobnie przesłonięte w wierszu poleceń
override CFLAGS &= -Wall # Bezwarunkowo dodane

W starych plikach makefile zazwyczaj trzeba było zrobić coś takiego, co miało side
efekt wymuszenia typu na „:=", aby zapobiec niekończącej się rekurencji:

ZMIENNA := wyrażenie $(ZMIENNA)

?=
ZMIENNA ?= wyrażenie
override ZMIENNA ?= wyrażenie # Bezużyteczne, ale legalne

Ustawia wartość zmiennej, ale tylko wtedy, gdy zmienna nie została określona wcześniej w
plik makefile, w wierszu poleceń lub w środowisku. Powyższe zadanie to
dokładnie równoważne

ifndef ZMIENNA
ZMIENNA = wyrażenie
endif

!=
ZMIENNA != polecenie powłoki
zastąp ZMIENNĄ != polecenie powłoki

Uruchamia polecenie powłoki i ustawia zmienną tak, aby zawierała standardowe wyjście polecenia.
To jest dokładnie równoważne

ZMIENNA := $(polecenie powłoki)

Wielowierszowy zmienne

Instrukcja „define” jest wielowierszowym odpowiednikiem powyższych prostych instrukcji. The
operator po zmiennej jest opcjonalny. Jeśli brakuje, jest to równoznaczne z „zdefiniuj ZMIENNĄ
=". Operatory "&=" i "+=" są tutaj nieco inne, ponieważ przyklejają to do
starą wartość znakiem nowej linii zamiast spacji. Nie może być nic poza a
komentarz po instrukcji, tzn. wartość zaczyna się od następnej linii.

zdefiniuj ZMIENNĄ :=
pierwsza linia wartości zmiennej
druga linia wartości zmiennej
trzecia linia wartości zmiennej
koniec

zastąp zdefiniowanie ZMIENNEJ
...
koniec

Słowa kluczowe przed „definiuj” mogą być kombinacją słów „eksport” lub „globalny” i
"nadpisanie".

Jeśli chcesz, aby wartość zmiennej zawierała znaki nowej linii, musisz użyć instrukcji „define” jako
pokazana (lub możesz przypisać wartość bezpośrednio w Perlu). (wybrano „endef”.
kompatybilność z GNU make. Możesz także użyć „enddef”.) Jest to przede wszystkim przydatne
„puszkach sekwencji poleceń”, np. coś takiego:

zdefiniuj COMPILE_C_PROGRAM
@&echo "Kompilowanie $(wejście)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(ZAWIERA) -c $(wejście) -o $(wyjście)
koniec

Następnie możesz użyć tej wielowierszowej zmiennej w kilku regułach, takich jak ta:

%.o: %.c
$(COMPILE_C_PROGRAM)

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

Pamiętaj, że często możesz osiągnąć ten sam efekt, używając średnika zamiast znaku nowej linii,
ponieważ powłoka interpretuje to również jako ogranicznik polecenia. Na przykład,

COMPILE_C_PROGRAM = @echo "Kompilowanie $(dane wejściowe)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(ZAWIERA) -c $(dane wejściowe) -o $(wyjście)

będzie miał ten sam efekt, z tą różnicą, że średnik zmusza Perla do przekazania go do powłoki,
zamiast bezpośredniego i wydajniejszego wykonywania polecenia. Musisz także umieścić każdy
wbudowany w osobnej linii, co oznacza, że ​​musisz przełączyć się na echo zewnętrzne w
przypadek średnika.

Istnieje jedna specjalność podczas rozwijania w obrębie „define”, tj. „define X :=" lub na a
zmienna, która już była „:=", „zdefiniuj X &=" i „zdefiniuj X +=". W tym przypadku
„$(polecenie powłoki ...)” lub wbudowane „$(&polecenie ...)” nie powodują przekształcenia znaków nowej linii w
spacje.

Eksportowanie zmienne do podprocesy

eksportuj VAR...
eksport VAR = wartość
zastąp eksport VAR += wartość

Pierwsza forma oznacza podane zmienne do eksportu do podprocesów, o dowolnej wartości
zmienna ma wtedy. Druga forma, która dotyczy tylko jednej zmiennej, dodatkowo
od razu przypisuje wartość. Dopuszczalne są wszystkie warianty przypisania.

Udostępnianie zmienne w poprzek makefile

globalny VAR...
globalny VAR = wartość
zastąp globalną wartość VAR &=

Pierwsza forma oznacza podane zmienne jako globalne dla wszystkich plików makefile. Jeśli któryś z nich
ma już wartość, wartość ta jest przenoszona ze zmiennej lokalnej pliku makefile do zmiennej globalnej
jeden. Jeśli jednak w momencie wyświetlenia tej instrukcji inne pliki makefile miały już rozszerzenie
wartość dla dowolnego z nich, wówczas te pliki makefile nie będą widzieć pliku globalnego.

Druga forma, która dotyczy tylko jednej zmiennej, dodatkowo przypisuje wartość właściwą
z dala. Dopuszczalne są wszystkie warianty przypisania. Pamiętaj, że „:=" od razu się rozwinie
do wartości w lokalnym pliku makefile. Wręcz przeciwnie, zmienne „=” rozwiną się do
wartości w miejscu użycia.

Zmienne globalne mogą być trudne w obsłudze, ponieważ makepp może ładować pliki makepp w dowolnym
kolejności, gdy zajdzie potrzeba zbudowania jakiegoś celu, dla którego nie są ładowane żadne reguły ani pliki makefile.
Z tego powodu zaleca się posiadanie Plik rootMakepp i jawnie załadować wszystko
inne, które modyfikują lub używają zmiennej z „load-makefile”.

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

Pamiętaj również, że Twój projekt może pewnego dnia zostać zbudowany razem z innymi projektami. Dla tego
dlatego zaleca się, aby nazwa projektu zawsze była częścią dowolnej nazwy zmiennej globalnej.

Specyficzne dla celu Zadania

cel: ZMIENNA = ciąg znaków
cel: ZMIENNA := ciąg
cel: zastąp ZMIENNĄ += ciąg

Ustawia wartość zmiennej specyficzną dla obiektu docelowego. Obowiązuje wartość specyficzna dla celu tylko
w działaniu, które daje dany cel. Jest to używane głównie do takich rzeczy jak
to:

CFLAGI := -O2

mój_prog: plik1.o plik2.o plik_specjalny.o

plik_specjalny.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(wejście) -o $(wyjście)

Dzieje się tak dlatego, że wszystkie pliki „.c” zostaną skompilowane z optymalizacją („-O2”) z wyjątkiem
„special_file.c”, który jest kompilowany w trybie debugowania („-g”). Jest to wygodny sposób
określ różne opcje kompilacji tylko dla kilku plików.

Takie przypisania zmiennych specyficznych dla celu mają zastosowanie tylko do działań reguły; Oni
nie obowiązują przy ocenie celów lub zależności reguły. Jeśli zasada
ma więcej niż jeden cel, przypisania zmiennych specyficznych dla celu są pobierane tylko z
drugim cel. Należy również pamiętać, że zmienne specyficzne dla celu makepp są nieco inne
z GNU make's, ponieważ odnoszą się one tylko do reguły dla jednego wspomnianego pliku, a nie do
którykolwiek z jego poprzedników.

Rozwijanie symboli wieloznacznych jest wykonywane na obiekcie docelowym, więc możesz zrobić coś takiego:

test_*.o : CFLAGS += -DTEST

Aby zapewnić zgodność z marką GNU, zamiast „*” można użyć „%”.

Zmienna Podstawienie
Zasady zastępowania zmiennych Makeppa są podobne do zasad innych marek, ale w pewnym stopniu
mocniejszy. Jak we wszystkich markach, oba „$(CC)” i „${CC}” reprezentują wartość
zmienna CC. Jeśli potrzebujesz dosłownego znaku dolara, wstaw podwójny znak dolara ($$), np
to:

cel: dep1 dep2 de3 dep4
&rm -f $(wyjście)
dla pliku w $(wejścia); wykonaj cat $$plik >> $(wyjście); zrobione

Dodatkowo makepp ma składnię „$[VARIABLE]”, która robi to samo, co druga
dwa, ale zanim Makepp coś jeszcze wymyśli. Pozwala to na wykorzystanie go do kompletnych reguł
i/lub warunki:

zdefiniuj regułę_nawiasu =
ifdef SOME_VAR
nawias:
&echo to jest reguła -o $(wyjście)
endif
koniec

$[reguła_nawiasu]

rc-styl podstawienie

Domyślnie makepp używa podstawienia w stylu rc (tak zwanego, ponieważ jego pionierem był
powłoka RC). Najlepiej zilustruje to przykład:

MODUŁY = abcd

mylib.a : katalog_modułu/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(zależności) -o $(cel)

Przedrostek „katalog_modułu/” jest dołączany do każdego słowa w MODUŁACH, a przyrostek „.o” to
dołączone do każdego słowa.

Możesz także użyć podstawienia w stylu rc, nawet bez umieszczania listy słów w a
zmienny; składnia to „$(słowo1 słowo2)”. Zwróć uwagę na odstęp między nawiasem a
pierwsze słowo. Zatem powyższy przykład można zapisać jako:

mylib.a : katalog_modułu/$(abcd).o $(OTHER_OBJECTS)
$(CXX) $(zależności) -o $(cel)

Zmienna daje podstawienie w stylu rc tylko wtedy, gdy jest w niej więcej niż jedno słowo.
Jednym słowem to jak tradycyjna produkcja. Niestety, gdy zmienna jest pusta, pojawia się a
konflikt. Tradycyjne sprawia, że ​​wystarczy rozwinąć go do pustego ciągu. Ale kiedy pomyślisz
jeśli chcesz, aby „-I$(DIRLIST)” zniknęło, a nie pojawiło się samotne „-I”. The
rozwiązaniem jest zawinięcie go w listę zaczynającą się od spacji: „-I$( $(DIRLIST))” daje
dokładnie tyle opcji, ile jest słów na liście.

Jeśli umieścisz kilka zmiennych w tym samym słowie, które rozwiną się do tablic słów, rc-style
podstawienie faktycznie bierze iloczyn kartezjański, więc możesz zrobić coś takiego if
chcesz:

KARIERA = s1 s2
MODUŁY = abc
PRZYrostki = .o.c
PLIKI := $(KATALOGI)/$(MODUŁY)$(SUFIKSY)

i FILES będą zawierać ciąg

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

Oprócz białych znaków podstawienie w stylu rc zatrzymuje się na dowolnym cudzysłowie, dowolnym okrągłym, kręconym lub kwadratowym
nawiasy i dowolne z „, : ; = # @”. Pamiętaj, że może to być zaskakujące i znowu potrzebne
wyraźną listę. Załóżmy, że chcesz szukać nagłówków za pomocą symboli wieloznacznych we wszystkich katalogach
zaczynając od dużej litery:

ZŁY := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
DOBRY := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Jeśli podstawienie w stylu rc przeszkadza lub jeśli potrzebujesz początku lub końca
białych znaków w zmiennych make, możesz wyłączyć podstawienie w stylu rc, ustawiając
zmienna „makepp_simple_concatenation=1”. Możesz wyłączyć to globalnie za pomocą polecenia
line lub jako zmienna środowiskowa. Lub na podstawie pliku makefile, ustawiając zmienną in
twój plik makefile. Powinieneś to zrobić w pobliżu górnej części pliku makefile, w przeciwnym razie możesz natknąć się na
zabawne sytuacje, w których w niektórych ocenach stosuje się podstawienie w stylu rc, a w innych nie.
(Wszystkie wyrażenia ocenione przed przypisaniem będą używać podstawień w stylu rc i all
wyrażenia oceniane po will not. Od czasu oceny wyrażeń w
makefiles jest skomplikowany i nie zawsze oczywisty z kolejności instrukcji w pliku
makefile, najlepiej ustawić „makepp_simple_concatenation” tak wcześnie, jak to możliwe.) Możesz
nawet ustaw go tylko dla jednego celu:

cel: makepp_simple_concatenation = 1
cel:
&echo before_first$(LISTA)po_ostatnim -o $(wyjście)

Ponieważ „$[VARIABLE]” jest obliczane wcześniej niż „$(VARIABLE)”, łącząc je w rc-
podstawienie nie da rezultatu, jakiego możesz się spodziewać, chyba że owiniesz je jawnie
lista:

A = ok
N = 1 2
ZŁY := $(A)$[N]
DOBRY := $(A)$( $[N])

Ostatnie wiersze są odczytywane jako

ZŁY := $(A)1 2 # a1 b1 2
DOBRY := $(A)$( 1 2) # a1 a2 b1 b2

Podstawienie Referencje

Odniesienie do podstawienia ma postać „$(VAR:A=B)”, gdzie A jest wzorcem do dopasowania, a B jest
wzór, którym można go zastąpić. Odniesienia do podstawień są skrótem od
funkcja „patsubst”. Na przykład:

pliki_źródłowe = ac bc cc dc
pliki_obiektów = $(pliki_źródłowe:%.c=%.o)

ustawi „$(object_files)” na „ao bo co do”. „%” to dopasowanie znaku specjalnego
dowolny dowolny ciąg. Jeśli zarówno A, jak i B zaczynają się od „%”, jest to częsty przypadek wymiany
przyrostki, można je pominąć:

object_files = $(pliki_źródłowe:.c=.o)
object_files = $(source_files:c=o) # to samo, ponieważ . nie jest wyjątkowy

Biała przestrzeń in zmienne

Jeśli chcesz kontrolować białe znaki w zmiennej, musisz (obecnie) wyłączyć styl rc
podstawienie (ustawiając „makepp_simple_concatenation=1”), a następnie użyj takiej składni:

zero =
T = -o $(null)

lub z pustą oceną:

T = -o $()

Gdy to zrobisz, zmienna „T” zawiera „-o”, po którym następuje spacja.

Tego rodzaju technika obsługi białych znaków nie jest zalecana. Jeśli potrzebujesz zmiennych
w pliku makefile, aby zawierał spacje, powinieneś poważnie przemyśleć to, co robisz.
Jeśli musisz obsługiwać spacje, zwykle znacznie lepiej jest umieścić kod Perla w pliku
makefile, aby się tym zająć (używając instrukcji „perl_begin” lub „sub”) lub aby się nim zająć
w instrukcjach powłoki w działaniach reguł.

Takie przypadki zwykle pojawiają się, gdy ludzie próbują zastosować te same zasady do różnych
architektury, które nie używają typowej składni poleceń uniksowych. Np. czasem się widzi
takie rzeczy w plikach makefile:

ifeq ($(ARCH), dziwak)
O := /WYJŚCIE=
więcej
zero :=
O := -o $(null)
endif

%.o: %.c
$(KOMPILER) $(wejście) $(O)$(wyjście)

Możesz to zrobić za pomocą makepp, jeśli naprawdę chcesz, ale prawdopodobnie przekonasz się, że your
pliki makefile są znacznie bardziej czytelne, jeśli masz mniej skomplikowaną zmienną
substytucja, np.

ifeq ($(ARCH), dziwak)
%.o: %.c
$(WEIRD_COMPILER) $(wejście) /WYJŚCIE=$(wyjście)
więcej
%.o: %.c
$(CC) -c $(wejście) -o $(wyjście)
endif

Białe znaki nigdy nie są dozwolone w nazwach zmiennych, a jedynie w ich wartościach. To jest inne
z niektórych dokonać wdrożeń.

automatycznie Zmienne
Zmienne automatyczne to zmienne, które przyjmują różne wartości w zależności od reguły
są one oceniane w. Makepp obsługuje większość zmiennych automatycznych niż inne
wersje make use. Ponadto większość z nich ma mniej tajemnicze i dłuższe nazwy
którego możesz użyć zamiast tego. (W przypadku starszych plików makefile, które na nowo definiują te nazwy, plik
definicja w pliku makefile zastępuje domyślne znaczenie. Na przykład, jeśli powiesz
„target = abc” w pliku makefile, wówczas „$(target)” zawsze rozwinie się do „abc” i nie będzie
nie będzie już odpowiednikiem $@.)

Poniżej znajduje się pełna lista wszystkich zmiennych automatycznych obsługiwanych przez makepp:

wydajność
cel
$@ Cel bieżącej reguły. Właściwie, ponieważ makepp obsługuje wiele celów dla
jakakolwiek zasada, to jest drugim cel. Na przykład w poniższej regule

y.tab.c y.tab.h : parser.y
$(YACC) -o $(wyjście) $(YFLAGS) $(wejście)

„$(wyjście)” będzie zawierać wartość y.tab.c. Ponieważ te magiczne zmienne są w rzeczywistości
funkcji, możesz także przekazać indeks jako argument. Liczy się od 1 lub wstecz
od 1. Zatem „$(wyjście 2)” lub „$(wyjście -1)” będzie zawierać wartość y.tab.h.

Chociaż wszystkie trzy formy tej zmiennej mają tę samą wartość, istnieje różnica
interpretacja reguł dotyczących wielu celów. Jeśli użyjesz tajemniczej nazwy $@ w starym stylu,
makepp zinterpretuje to jako zestaw reguł w starym stylu, a nie jako regułę nowoczesną
produkuje wszystkie te cele za jednym razem:

ab: # naprawdę: po jednej zasadzie dla a i b
dotknij $@

cd: # błąd: mpp skarży się, że to nie zbudowało d
dotknij $ (wyjście)

Wyjścia
cele
Wszystkie cele bieżącej reguły. To samo co „$(target)”, chyba że jest ich więcej niż jeden
cel. W powyższym przykładzie „$(wyjścia)” będzie wynosić y.tab.c y.tab.h. Można przejść
lista indeksów, więc „$(wyjścia 2 1)” będzie mieć postać y.tab.h y.tab.c.

zależność
wkład
$< Pierwsza jawna zależność reguły. Na przykład w tej zasadzie

%.o: %.c
$(CC) $(CFLAGS) -c $(wejście) -o $(wyjście)

„$(input)” będzie nazwą pliku .c plik, niezależnie od tego, co .h pliki makepp
odkrywa. Jeśli określisz więcej niż jedną zależność, możesz je uzyskać, przekazując an
indeks: "$(input $(INDEX))" to zależność INDEKSU.

Zależności
Wejścia
$^ Wszystkie jawne zależności celu, z wyłączeniem .h pliki odkryte przez
makepp_scanning dla zawiera.

Na przykład w przepisie

mójprog.o : *.o
$(CC) $(CFLAGS) $(wejścia) -o $(wyjście)

„$(wejścia)” będą wszystkimi plikami .o w katalogu. Możesz wybrać tylko te, które ty
chcesz, przekazując listę indeksów. Jeśli wyraźnie określisz różne rodzaje plików,
możesz je wybrać jak w „$(inputs 2 3 4)” (ale z symbolem wieloznacznym nie jest to zbyt
obiecujący).

sortowane_zależności
posortowane_wejścia
$+ Wszystkie zależności celu, w posortowanej kolejności, z usuniętymi duplikatami.
Odpowiednik „$(sort $(wejścia))”.

zmienione_zależności
zmienione_wejścia
$? Zależności celu, które uległy zmianie. Obejmuje to tylko wyraźne
zależności (tj. te, które wyszczególniasz w pliku makefile), które nie są domyślnie odkrywane
zależności ze skanowania (takie jak pliki .h).

Jest to powszechnie używane w poleceniach takich jak to:

libmine.a: $(MODUŁY): build_check ignorowanie_akcji
$(AR) ru $@ $?

to znaczy, ar poinstruowano, aby wymienić tylko te moduły, które uległy zmianie. (Zanotuj
Reguła sprawdzania kompilacji „ignore_action”. Jeśli tego nie określisz, makepp wymusi
akcja, która ma zostać wykonana przy każdej zmianie. Jeśli żadne zależności się nie zmieniły, plik
Ciąg akcji będzie miał postać „ar ru libmine.a”, co prawdopodobnie będzie się różnić od tego, co było wcześniej
ostatnim razem, gdy go uruchomiłeś, więc bez „ignore_action” makepp go wykona. W tym
przypadku jest to nieszkodliwe, ale w przypadku innych poleceń może stanowić problem. Widzieć
makepp_build_check, aby uzyskać szczegółowe informacje na temat „ignore_action”.)

Tworzenie takich archiwów nie jest dobrym pomysłem, ponieważ zmniejszy liczbę kompilacji
niezawodny. Problem polega na tym, że jeśli zbudujesz archiwum, usuń jedno z nich
moduły z listy MODUŁÓW, moduły nadal będą w archiwum i
makijaż

trzon
$* Rdzeń w regule wzorca (tzn. niezależnie od dopasowania „%”). Alternatywnie, jeśli to
nie jest regułą wzorca, zwraca nazwę pliku bez rozszerzenia (tj
odpowiednik „$(nazwa bazowa $(wejście))”.

Dotyczy to głównie kompatybilności wstecznej. Na przykład w starych wersjach make the
jedyny sposób, aby powiedzieć mu, jak skompilować dowolny .c plik do odpowiedniego pliku .o plik był podobny
to:

.współ:
$(CC) $(CFLAGS) -c $*.c -o $*.o

To kiepski sposób na napisanie reguły. O wiele jaśniejsze jest użycie stylu GNU-make
reguły wzorców, takie jak to:

%.o: %.c
$(CC) $(CFLAGS) -c $(wejście) -o $(wyjście)

foreach
Bieżąca nazwa pliku z klauzuli „foreach”. Klauzule „foreach” są rzadko używane,
ale są to najbardziej uniwersalne reguły wzorców obsługiwane przez makepp. Dla
przykład,

#
# Kompiluj pliki .c za pomocą specjalnego preprocesora:
#
%.c: %.k
$(preprocesor) $(wejście) > $(wyjście)

#
# Kompiluj pliki .c do plików .o:
#
%.o: %.c
$(CC) $(CFLAGS) -c $(wejście) -o $(wyjście)

#
# Specjalne alternatywne flagi kompilacji dla pochodnych plików .c
# z plików .k:
#
$(foreach:%.k=%.o): $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(wejście) -o $(wyjście)

Więcej szczegółów i przykładów można znaleźć w dokumentacji klauzuli fore w regułach.

$/ Jest to zasadniczo stała, „/” lub w natywnym systemie Windows „\”. Potrzebujesz tego, jeśli
chcesz uruchomić program przenośnie, np. taki, który zbudowałeś w bieżącym katalogu:

moje wyjście:
.$/mójprog >$(wyjście)

W przypadku nazw plików przekazywanych jako argumenty nie jest to konieczne, ponieważ Windows radzi sobie z Unixem
tam składnia.

Option Zmienne
Można je ustawić na wszystkie sposoby opisane powyżej (o ile nie podano inaczej), aby je zmodyfikować
zachowanie makepp. Domyślnie wszystkie są niezdefiniowane.

MAKEPP_DEBUG
Jeśli wyeksportujesz to z wartością true przed wywołaniem makepp, uzyskasz więcej debugowania
informacje. To jest „RULE_SOURCE” plików zbudowanych w okresie obowiązywania tej zasady
makeppinfo, mppi i szczegóły dotyczące rozwijania zmiennych i dopasowywania reguł w sekcji
makepplog, mppl. To pokaże Ci również, czy w Makepp zabraknie pamięci lub zawiesi się,
ponieważ w nieskończoność rozwija te same zmienne:

A = $A # odroczona ocena, potrzeba :=
B = $C
C = $B

MAKEPP_LN_CP
Zobacz uwagę pod &ln.

makepp_percent_podkatalogi
Ustaw tę wartość na jakąś prawdziwą wartość (np. 1), aby „%” w celach lub zależnościach było zgodnych
w więcej niż jednym katalogu.

makepp_require_phony
Ustaw tę wartość na jakąś prawdziwą wartość (np. 1), aby zapobiec ukrytej fałszywości (tzn. jeśli reguła
powiedzie się bez osiągnięcia celu). Ta zmienna powinna domyślnie mieć wartość true, to
zapobiegać zerwaniu łańcuchów zależności, ale to złamałoby wsteczną kompatybilność z
niechlujne pliki makefile.

makepp_signature_C_flat
Jest to opcja podpisu C. Ustaw tę opcję na jakąś prawdziwą wartość (np. 1), aby leczyć swoje
źródła są spłaszczone, tj. wszystkie znaki nowej linii (z wyjątkiem instrukcji preprocesora) są takie
traktowane jak białe znaki i dyrektywy „#line” są ignorowane.

makepp_simple_concatenation
Ustaw tę wartość na jakąś prawdziwą wartość (np. 1), aby zapobiec „podstawianiu w stylu rc”.

Perła
Możesz ustawić dokładnie ten perl, którego używasz do uruchamiania skryptów w makepp
suite i wyeksportuj go. Może to pomóc w uruchomieniu skryptów dolnych w tym samym perlu. To jest
przydatne głównie w zestawie testów, instalacji i kompilacjach rekurencyjnych.

ŚCIEŻKA V
Ustawienie tej zmiennej na jakąś wartość pośrednio wywołuje „% wartości vpath”.

Predefiniowane Zmienne
Makepp predefiniuje kilka zmiennych, które możesz zastąpić:

AR Zaniedbanie: „ar”.

ARFLAGI
Zaniedbanie: „rv”.

AS Zaniedbanie: "Jak".

CC Zaniedbanie: Pierwszy znaleziony wśród „gcc”, „egcc”, „pgcc”, „c89” lub „cc” lub w systemie Windows
dodatkowo „cl” lub „bcc32”.

CFLAGI
Zaniedbanie: Jeśli „$(CC)” jest kompilatorem GNU „-g -Wall”, jeśli jest to jeden z dwóch
kompilatory nic, w przeciwnym razie „-g”.

KURDYR
Katalog, w którym znajduje się bieżący plik Makefile.

CXX Zaniedbanie: Pierwszy znaleziony wśród „g++”, „c++”, „pg++”, „cxx”, „C”, „C” lub „aCC” lub na
Windows dodatkowo „cl” lub „bcc32”.

CXXFLAGI
Zaniedbanie: Jeśli „$(CXX)” jest kompilatorem GNU „-g -Wall”, jeśli jest to jeden z dwóch
kompilatory nic, w przeciwnym razie „-g”.

F77 Zaniedbanie: Pierwszy znaleziony wśród „f77”, „g77” lub „fort77”.

FC Zaniedbanie: „$(F77)”.

LD Zaniedbanie: „ld”.

LEX Zaniedbanie: Pierwszy znaleziony wśród „lex” lub „flex”.

LIBTOOL
Zaniedbanie: „libtool”.

MAKE
Zmienna ta ma dwie różne wartości, w zależności od obecności lub braku
„--tradycyjna konstrukcja-rekurencyjna”. Makepp rozpoznaje, kiedy ta zmienna jest używana i
wyłącza niektóre funkcje, nawet zanim faktycznie nastąpi rekurencja. To może być
niepożądane, gdy będziesz je stopniowo eliminować, więc najpierw przekonwertuj wywołania na a
makepp specyficzne „$((MAKE))”, które nie wyłączy funkcji. Nie powinieneś tego ustawiać
ponieważ to psuje naszą inteligentną rekurencję.

MAKECMDGOALS
Ta zmienna jest ustawiona, ale nie jest używana przez makepp. Możesz zapytać go, aby coś zrobił tylko wtedy, gdy
zażądano określonego celu.

Zaniedbanie: Jakikolwiek jawny cel podany przez użytkownika (lub wywołanie rekurencyjne).
Puste podczas niejawnego budowania domyślnego celu.

ifneq $(filtruj cel specjalny, $(MAKECMDGOALS))
# cel specjalny jest jednym z bieżących jawnych celów
else ifeq $(MAKECMDGOALS)
# brak wyraźnych celów
endif

MAKEFLAGI (eksportowane)
Standardowe opcje, za pomocą których wywoływano makepp. Te, które mają jedną literę
formy są łączone na początku bez wiodącego „-” (niebo wie, dlaczego wybrał gmake
aby usunąć „-”).

INFO
Zaniedbanie: „makeinfo”.

MAKEPPFLAGS (eksportowane)
Jest ona ustawiona na tę samą wartość co MAKEFLAGS, ale tylko jeśli ta zmienna jest obecna w
środowisko Makepp.

_MAKEPPFLAGS (eksport)
Opcje specyficzne dla makepp potrzebne do zgodności z POSIX/gmake, z którymi makepp
został wezwany. Znajdują się one w osobnej zmiennej, więc starszy plik makefile nie może się zepsuć
kompatybilność poprzez odznaczenie MAKEFLAGS. Jest to ustawione tylko za pomocą
„--tradycyjna konstrukcja-rekurencyjna”.

MAKEPP_VERSION
Wersja makepp, z której korzystasz. Jeśli jest to wersja beta, będzie ona miała
łącznik, po którym następuje RRMMDD i trochę więcej danych wewnętrznych. Możesz użyć tego dla „ifdef”
aby ukryć konstrukcje specyficzne dla Makepp przed innymi markami.

Zaniedbanie: Ta sama wartość wyświetlana przez „makepp --version”

PWD Alias ​​dla „CURDIR”.

RM Zaniedbanie: „rm -f”. Dotyczy to starszych plików Makefile. W przypadku nowych najlepiej użyć
bezpośrednio wbudowane polecenie &rm. Jeśli chcesz napisać fałszywą, czystą regułę, spójrz na
zamiast tego użyj polecenia „makeppclean -r”.

ROOT
Ścieżka względna do katalogu głównego systemu kompilacji, tj. katalogu znajdującego się wyżej
w którym masz plik „RootMakeppfile(.mk)”. Jeśli jej nie masz, jest to ta zmienna
pusty.

SHELL
Ta zmienna jest przestrzegana tylko wtedy, gdy ją „eksportujesz”. W takim razie jest to Shell
który służy do wykonywania niewbudowanych akcji zawierających jakiś specjalny znak (plain
te wykonywane bezpośrednio). W systemie Windows Strawberry lub ActiveState Perl, jeśli masz
powłokę typu uniksowego, musisz zamiast tego ustawić zmienną SHELL na wartość kończącą się na „sh”
lub „sh.exe” zanim Dzwonię do Makeppa.

Zaniedbanie: Pierwszy znaleziony wśród „/usr/xpg4/bin/sh” (np. Solaris) lub „/sbin/xpg4/sh”
(np. Reliant Unix) lub „/ Bin / sh".

YACC
Zaniedbanie: Pierwszy znaleziony wśród „bizon -y” lub „yacc”.

Zmienne i Perl
Wartości zmiennych są przechowywane jako zwykłe skalary Perla, dzięki czemu można uzyskać do nich bezpośredni dostęp
Kod Perla, jeśli chcesz wykonać na nich jakieś skomplikowane manipulacje; zobacz makepp_extending
dla szczegółów.

Dostęp do zmiennych globalnych z Perla uzyskuje się poprzez poprzedzenie ich przedrostkiem „Mpp::global”
pakiet. W rzeczywistości dowolna zmienna, jeszcze nieobecna w bieżącym pliku makefile, a którą ty
przypisania do w tym pakiecie będzie odtąd globalny, tak jakbyś właśnie wydał plik
„globalne” oświadczenie w tej sprawie.

Ten bezpośredni dostęp jest jednak podatny na błędy! Użytkownik mógł zastąpić te zmienne
w wierszu poleceń lub poprzez środowisko. Jakiś inny plik makefile załadowany wcześniej
można było ustawić zmienną globalną lub specyficzną dla celu. W takich przypadkach nie
znaleźć wartość zmiennej lub przypisując ją, może odebrać jej właściwość
(odpowiednik modyfikatora „przesłonięcia”, z wyjątkiem specyfiki celu.)

Dzięki bezpośredniemu dostępowi pomijasz także rozwijanie tych zmiennych, jeśli są one typu
„=" lub „;=". Zmienne specjalne, takie jak „$(CC)”, zaczynają od funkcji, dopóki nimi nie są
przypisane do. Dlatego w wielu przypadkach nie zobaczysz ich wartości.

Z tych powodów lepiej pozwolić makeppowi określić poprawną wartość. Możesz skorzystać z
Wariant „makeperl”, w którym zmienna została oceniona przed otrzymaniem kodu Perla
interpretowane:

makeperl { $$bieżąca_wartość = '$(MAKEFILE_VAR)' }

Jeśli potrzebujesz zmiennej w blokach Makefile Perla, można to osiągnąć poprzez zmienną Perla
$makefile w następujący sposób:

perl { $bieżąca_wartość = $makefile->expand_variable( 'MAKE_VAR') }

Funkcje zawsze otrzymują obiekt makefile przekazywany jako drugi argument $_[1]:

sub f_f { $bieżąca_wartość = $_[1]->rozwiń_zmienną( 'MAKE_VAR') }

Polecenia powinny być wywoływane w ramach akcji reguły, w której znajduje się obiekt makefile
dostępne poprzez „$Mpp::Subs::rule->{MAKEFILE}”:

sub c_cmd { $bieżąca_wartość = $Mpp::Subs::rule->{MAKEFILE}->expand_variable( 'MAKE_VAR' ) }

Użyj makepp_variables online, korzystając z usług onworks.net