makepp_variables - Bulutta Çevrimiçi

Program:

ADI

makepp_variables -- Makepp'te değişkenler nasıl kullanılır

TANIM

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAKLAR,
GİBİ, C: DC,
FLAGLAR,
"değişen_bağımlılıklar",
change_inputs,
KÜRDİR,
müşteri,
CXXFLAG'LAR, D: "bağımlılıklar",
"bağımlılık", F: F77,
FC,
"her biri için", I: giriş,
giriş, L: LD,
LEX,
LİBTOOL, M: YAPMAK,
MAKECMDHEDEFLER,
MAKEFLALAR,
BİLGİLENDİRME,
MAKEPP_DEBUG,
MAKEPPFLAG'lar,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEP_VERSION YAPIN, O: "çıktı",
"çıktılar", P: PERL,
özürlü, R: RM,
KÖK, S: KABUK,
"sıralanmış_bağımlılıklar",
sıralanmış_girişler,
"kök", T: hedef,
hedefler, V: VPATH, Y: YACC

Makefile'lar tipik olarak birçok yerde değişkenleri kullanır. kullanmanın önemli bir nedeni
değişkenler, bilgilerin makefile'de yalnızca bir yerde bulunmasını sağlamak içindir, bu nedenle
değişirse, bilgilerin iki kopyasının dışarı çıkma tehlikesi yoktur.
senkron.

Değişken isimleri büyük/küçük harf duyarlıdır. Teoride, değişken isimleri birçok
karakterler, ancak bunun dışında bir şey yaparsanız makepp muhtemelen onu okuyamaz.
alfasayısal karakterler, "_" ve "-".

Her makefile kendi değişken grubuna sahiptir ve bir makefile'de bir değişken ayarlamak,
başka bir makefile içindeki değeri üzerinde hiçbir etkisi yoktur. Değişkenlerin ayarlanmasını istiyorsanız
birçok makefile, bunu yapmanın en iyi yolu, her birinin ortak bir tanım içermesini sağlamaktır.
dosya (include deyimine bakın) veya "global" değişkenleri kullanın.

Değişken Atama
Bir değişken birkaç farklı şekilde bir değer alabilir:

· Bir makefile içinde bir değişken ayarlanabilir. yapmanın birkaç farklı yolu var
Bugün nasılsın; aşağıya bakınız.

· Bir değişkenin değeri komut satırında şu şekilde belirtilebilir:

makepp CFLAGS=-O2 my_programm

Birden fazla makefile yüklenmişse, CFLAGS değişkeni tüm
makefiles. Komut satırında ayarlanan değişkenler, herhangi bir ayarı otomatik olarak geçersiz kılar.
herhangi bir makefile içindeki değişken.

Gerekirse, makefile sırayla komut satırı ayarlarını açıkça geçersiz kılmalıdır.
Amaç, kullanıcının isteklerini görmezden gelmek değil, onu değiştirmenin bir yoludur.
"Geçersiz kılma" değiştiricisi, herhangi bir atama ifadesinden önce gelebilir. Ama durumunda
anahtar kelime ifadeleri, sıra önemlidir, bu nedenle geçersiz kılma varyantı
her zaman aşağıda gösterilmiştir. "Geçersiz kılma" değiştiricisi, yalnızca geçerli olduğu tüm atamalar için geçerlidir.
mevcuttur ve değişkene sonraki atamaları etkilemez.

· Ortamda bir değişken ayarlanmışsa, makepp değişkeni olarak başvurulabilir.
Normalde bir makefile içindeki değişkenlere atamalar,
ancak bunu "-e" veya "--environment-overrides" kullanarak değiştirebilirsiniz.
komut satırı seçeneği.

Değişkenler, bunun gibi birkaç atama ifadesinden biriyle atanır.

X = 1
MODÜLLER := abcd
cc ?= gcc
CFLAGS += -Duvar
VAR'ı tanımla
var satır 1
var satır 2
son tanım
YOLU dışa aktar := $(PWD):$(YOL)
global MYPROJECT.INFO = tüm makefile'lerde görülecek bilgi

Değerlerin başındaki ve sonundaki boşluklar her zaman çıkarılır.

Farklı atama operatörlerinin biraz farklı anlamları vardır.

Basit atama operatörler

=
DEĞİŞKEN = metin dizesi
DEĞİŞKEN = metin dizesini geçersiz kıl

Bu, make'nin tüm uygulamalarının desteklediği olağan atama ifadesidir. NS
sağ taraftaki ifade "$(VARIABLE)" değeri elde edilene kadar değerlendirilmez.
aslında bir yerde kullanılmıştır. Bu nedenle, aşağıdakileri yaparsanız:

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

Daha sonra makefile içindeki "$(Y)", "2" olarak değerlendirilir.

Genel olarak, genellikle "=" yerine ":=" (aşağıya bakın) kullanmak istersiniz çünkü
daha öngörülebilir değişken değerlendirmesi sağlar. Ancak, ihtiyaç duyduğunuz zamanlar vardır.
değişken değerlendirmesini ertelemek için. Ayrıca, olması gereken bir makefile yazıyorsanız
GNU make dışındaki bazı make sürümleriyle geriye dönük uyumluysa,
seçim: sadece "=" kullanabilirsiniz.

:=
DEĞİŞKEN := ifade
DEĞİŞKEN := ifadeyi geçersiz kıl

Bu, sağ tarafın değerlendirilmesi dışında "DEĞİŞKEN = ifade" ile aynıdır.
bir kez ve herkes için görev sırasında. Böylece eğer

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

daha sonra makefile içindeki "$(Y)", "$(X)" olduğu için "1" olarak değerlendirilir.
"$(Y)" tanımlandığında.

;=
DEĞİŞKEN ;= ifade
DEĞİŞKEN ;= ifadeyi geçersiz kıl

Bu, sağ tarafın değerlendirilmesi dışında "DEĞİŞKEN := ifade" ile aynıdır.
sadece ilk kullanım sırasında ve daha sonra hatırlanır. Bu pahalı için yararlıdır
her zaman aynı değeri döndüren, ancak ne zaman gerçekleştirmek istemediğiniz komutlar
alakasız hedefler oluşturmak:

VAR1 ;= $(Perl pahalı hesaplamaları)
VAR2 ;= $(harici kabuk komutu)

Eski makefile dosyalarının genellikle burada ":=" kullanacağını, en azından bunu yalnızca bir kez yapacağını unutmayın.
Ancak bu operatörle, şu anda yapmadıysanız, ek olarak yapamazsınız.
değere ihtiyacı var. Birkaç dizinde aynı olan değerler için şunları yapabilirsiniz:
bunu aşağıda tartışılan "küresel" ile daha da optimize edin.

Ancak bu, değerlendirme sırasını zorlamak için akıllıca bir yol olarak tasarlanmamıştır. Eğer bir
bu şekilde tanımlanan değişken, başka bir değişkenin değerini içerir ve diğer
hedefe özel bir değere sahiptir ve ilk genişleme bu hedef içindir, ardından
hedefe özel değer, diğer tüm bağlamlar için de geçerli olacaktır. Bu bir hata ve
umarım ileride düzelir.

+=
DEĞİŞKEN += ifade
DEĞİŞKEN += ifadeyi geçersiz kıl

Dizeyi, bir boşlukla ayırarak değişkenin önceki içeriğine ekler. Eğer
değişken daha önce ":=" ile atanmıştı, ardından sağ taraf değerlendirilir
eklemeden önce.

&=
DEĞİŞKEN &= ifade
DEĞİŞKEN &= ifadeyi geçersiz kıl

Dizeyi, bir boşlukla ayırarak değişkenin önceki içeriğinin başına ekler.
Değişken daha önce ":=" ile atanmışsa, sağ taraf
eklemeden önce değerlendirilir.

Örneğin, kullanıcı başka ne koyarsa koysun "CFLAGS"ı garanti etmenin bir yolu,
her zaman "-Wall" ile başlar şu iki satır:

CFLAGS = -O2 # Muhtemelen komut satırında geçersiz kılınmış
CFLAGS &= -Wall # Koşulsuz olarak başa eklenmiş geçersiz kıl

Eski makefile'lerde genellikle bunun gibi bir şey yapmak zorundaydınız.
sonsuz özyinelemeyi önlemek için türü ":=" olarak zorlamanın etkisi:

DEĞİŞKEN := ifade $(DEĞİŞKEN)

?=
DEĞİŞKEN ?= ifade
geçersiz kıl DEĞİŞKEN ?= ifade # Yararsız, ancak yasal

Değişkenin değerini ayarlar, ancak yalnızca değişken daha önce belirtilmemişse
makefile, komut satırında veya ortamda. Yukarıdaki atama
tam olarak eşdeğer

ifndef DEĞİŞKEN
DEĞİŞKEN = ifade
endif

!=
DEĞİŞKEN != kabuk komutu
DEĞİŞKEN != kabuk komutunu geçersiz kıl

Kabuk komutunu çalıştırır ve değişkeni komutun standart çıktısını içerecek şekilde ayarlar.
Bu tam olarak eşdeğerdir

DEĞİŞKEN := $(kabuk komutu)

Çok satırlı değişkenler

"define" ifadesi, yukarıdaki basit ifadelerin çok satırlı eşdeğeridir. NS
değişkenden sonraki operatör isteğe bağlıdır. Eksikse, "DEĞİŞKENİ tanımla" ile eşdeğerdir.
=". "&=" ve "+=" operatörleri burada biraz farklıdır, çünkü bunu şuraya yapıştırırlar.
boşluk yerine yeni satır içeren eski değer. dışında bir şey olmamalıdır.
açıklamadan sonra yorum yapın, yani değer sonraki satırda başlar.

DEĞİŞKEN tanımla :=
değişken değerinin ilk satırı
değişken değerinin ikinci satırı
değişken değerinin üçüncü satırı
Endef

DEĞİŞKEN tanımlamayı geçersiz kıl
...
son tanım

"tanımla"dan önceki anahtar kelimeler, "dışa aktarma" veya "küresel" kelimelerinden birinin kombinasyonları olabilir ve
"geçersiz kıl".

Yeni satırları içermek için bir değişkenin değerine ihtiyacınız varsa, "define" ifadesini şu şekilde kullanmalısınız:
gösterilir (veya değeri doğrudan Perl'de atayabilirsiniz). ("endef" için seçildi
GNU markasıyla uyumluluk. "enddef"i de kullanabilirsiniz.) Bu öncelikle aşağıdakiler için kullanışlıdır:
"hazır komut dizileri", örneğin şöyle bir şey:

COMPILE_C_PROGRAM'ı tanımla
@&echo "$(giriş) derleniyor"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(giriş) -o $(çıktı)
Endef

Ardından bu çok satırlı değişkeni aşağıdaki gibi birkaç kuralda kullanabilirsiniz:

%.o : %.c
$(COMPILE_C_PROGRAM)

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

Aynı efekti yeni satır yerine noktalı virgül kullanarak da elde edebileceğinizi unutmayın.
çünkü kabuk bunu da bir komut sınırlayıcı olarak yorumlar. Örneğin,

COMPILE_C_PROGRAM = @echo "$(giriş) derleniyor"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(INCLUDES) -c $(giriş) -o $(çıktı)

noktalı virgülün Perl'i kabuğa geçirmeye zorlaması dışında aynı etkiye sahip olacaktır,
komutu doğrudan ve daha verimli bir şekilde yürütmek yerine. Ayrıca her birini koymak zorundasın
kendi satırında yerleşiktir, yani
noktalı virgül durumda.

"define" içinde genişletirken bir uzmanlık vardır, yani "define X :=" veya bir
zaten ":=", "define X &=" ve "define X +=" olan değişken. bu durumda
"$(shell komutu ...)" veya yerleşik "$(&command ...)" yeni satırları dönüştürülmez
alanlarda.

İhracat değişkenler için alt süreçler

VAR'ı dışa aktar...
VAR'ı dışa aktar = değer
dışa aktarma VAR += değerini geçersiz kıl

İlk form, alt süreçlere dışa aktarma için verilen değişkenleri, değeri ne olursa olsun işaretler.
değişken daha sonra vardır. Yalnızca bir değişken için geçerli olan ikinci form, ek olarak
hemen bir değer atar. Tüm atama türlerine izin verilir.

Paylaşım değişkenler karşısında Makefile'lar

küresel VAR...
küresel VAR = değer
global VAR &= değerini geçersiz kıl

İlk form, verilen değişkenleri tüm makefile'ler için global olarak işaretler. eğer bunlardan herhangi biri
zaten bir değere sahipti, bu değer makefile yerel değişkeninden global değişkene taşınır
bir. Ancak, bu ifadenin görüldüğü sırada, başka herhangi bir makefile zaten bir
bunlardan herhangi biri için değer, o zaman bu makefiles global olanı görmeyecek.

Yalnızca bir değişken için geçerli olan ikinci form, ek olarak bir değer atar.
uzak. Tüm atama türlerine izin verilir. ":=" öğesinin hemen genişleyeceğini unutmayın
yerel makefile içindeki değerlere. Aksine "=" değişkenleri
Kullanım noktasındaki değerler.

Genel değişkenlerle uğraşmak zor olabilir, çünkü makepp makefile'leri herhangi bir
sipariş, hiçbir kural veya makefile yüklenmemiş bir hedef oluşturmak için ihtiyaç ortaya çıktığından.
Bu sebeple bir RootMakepp dosyası ve açıkça hepsini yüklemek için
değişkeni "load-makefile" ile değiştiren veya kullanan diğerleri.

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

Ayrıca projenizin bir gün diğer projelerle birlikte inşa edilebileceğini unutmayın. Bunun için
bu nedenle proje adının her zaman herhangi bir global değişken adının parçası yapılması önerilir.

hedefe özel ödevler

hedef: DEĞİŞKEN = dize
hedef: DEĞİŞKEN := dize
hedef: DEĞİŞKEN += dizeyi geçersiz kıl

Değişkenin hedefe özel bir değerini ayarlar. Hedefe özel bir değer etkin bir tek
verilen hedefi üreten bir eylemde. Bu öncelikle gibi şeyler için kullanılır
bu:

FLAGLAR := -O2

my_prog: dosya1.o dosya2.o özel_dosya.o

özel_dosya.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(girdi) -o $(çıktı)

Burada olan, tüm ".c" dosyalarının optimizasyon ("-O2") ile derlenmesidir. dışında
hata ayıklama modunda derlenen "özel_dosya.c" ("-g"). Bu uygun bir yoldur
yalnızca birkaç dosya için farklı derleme seçenekleri belirtin.

Bunun gibi hedefe özel değişken atamaları yalnızca kuralın eylemleri için geçerlidir; onlar
bir kuralın hedeflerini veya bağımlılıklarını değerlendirirken geçerli değildir. eğer bir kural
birden fazla hedefi varsa, hedefe özel değişken atamaları yalnızca
ilk hedef. Ayrıca makepp'in hedefe özel değişkenlerinin biraz farklı olduğuna dikkat edin.
GNU make's'ten, yalnızca belirtilen bir dosya için kural için geçerli oldukları ve
öncekilerden herhangi biri.

Hedefte joker karakter genişletmesi gerçekleştirilir, böylece şöyle bir şey yapabilirsiniz:

test_*.o : CFLAGS += -DTEST

GNU markasıyla uyumluluk için "*" yerine "%" kullanılabilir.

Değişken Ikame
Makepp'in değişken ikame kuralları, diğer markalarınkine benzer, ancak biraz
daha güçlü. Tüm markalarda olduğu gibi, "$(CC)" veya "${CC}" her ikisi de
değişken CC. Gerçek bir dolar işaretine ihtiyacınız varsa, örneğin bir çift dolar işareti ($$) koyun.
bu:

hedef: dep1 dep2 dep3 dep4
&rm -f $(çıktı)
$(girdi) içindeki dosya için; do cat $$file >> $(çıktı); tamamlamak

Ayrıca makepp, diğeriyle aynı şeyi yapan bir "$[VARIABLE]" sözdizimine sahiptir.
iki, ancak makepp başka bir şeyi groks etmeden önce. Bu, tam kurallar için kullanılmasına izin verir
ve/veya koşul cümleleri:

braket_kuralı tanımla =
ifdef SOME_VAR
parantez:
&echo bu bir kuraldır -o $(çıktı)
endif
son tanım

$[bracket_rule]

rc tarzı ikame

Varsayılan olarak makepp, rc tarzı ikame kullanır (bu isim,
rc kabuğu). Bu en iyi bir örnekle gösterilmektedir:

MODÜLLER = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(bağımlılıklar) -o $(hedef)

MODÜLLER'deki her kelimenin başına "module_dir/" ön eki getirilir ve ".o" soneki
her kelimeye eklenir.

Ayrıca, kelimelerin listesini bir dosyaya koymadan bile rc-tarzı ikameyi kullanabilirsiniz.
değişken; sözdizimi "$(kelime1 kelime2)" şeklindedir. parantez ve parantez arasındaki boşluğa dikkat edin
İlk kelime. Yani yukarıdaki örnek şu şekilde yazılabilirdi:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(bağımlılıklar) -o $(hedef)

Bir değişken, yalnızca içinde birden fazla kelime olduğunda rc tarzı ikame verecektir.
Tek kelime ile geleneksel yapım gibidir. Ne yazık ki, değişken boş olduğunda, bir
çatışma. Geleneksel yapar, onu boş dizeye genişletir. Ama düşündüğünde
bir liste olarak, "-I$(DIRLIST)" ifadesinin kaybolmasını, yalnız bir "-I" vermemesini istersiniz. NS
çözüm, onu bir boşlukla başlayan bir listeye sarmaktır: "-I$( $(DIRLIST))" size
tam olarak listede kelimeler olduğu kadar çok seçenek.

Aynı kelimeye, kelime dizilerine genişleyen birkaç değişken koyarsanız, rc-style
ikame aslında kartezyen çarpımı alır, bu nedenle eğer böyle bir şey yapabilirsiniz
İstediğiniz:

DIRS = s1 s2
MODÜLLER = abc
EKLER = .o .c
DOSYALAR := $(DIRS)/$(MODÜLLER)$(SONEKLER)

ve DOSYALAR dizeyi içerecektir

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

Beyaz boşluğun yanı sıra, herhangi bir alıntıda, herhangi bir yuvarlak, kıvırcık veya karede rc tarzı ikame durur
parantezler ve ", : ; = # @" öğelerinden herhangi biri. Bunun şaşırtıcı olabileceğini ve tekrar gerekli olduğunu unutmayın.
açık bir liste. Tüm dizinlerde üstbilgileri joker karakterle aramak istediğinizi söyleyin
büyük harfle başlayan:

KÖTÜ := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
İYİ := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Eğer rc-tarzı ikame engel oluyorsa veya önde ya da sonda olması gerekiyorsa
make değişkenlerinizdeki boşluk, ardından ayarlayarak rc tarzı ikameyi kapatabilirsiniz.
"makepp_simple_concatenation=1" değişkeni. Komutta global olarak kapatabilirsiniz
satır veya ortam değişkeni olarak. Veya değişkeni ayarlayarak makefile bazında
senin makefile. Bunu makefile dosyasının üst kısmına yakın bir yerde yapmalısınız, yoksa
Bazı değerlendirmeler için rc-tarzı ikamenin kullanıldığı, diğerlerinin kullanılmadığı komik durumlar.
(Ödevden önce değerlendirilen tüm ifadeler, rc tarzı ikameleri kullanacak ve tümü
sonra değerlendirilen ifadeler olmayacaktır. İfadelerin değerlendirilmesinden bu yana
makefiles karmaşıktır ve içindeki ifadelerin sırasından her zaman açık değildir.
makefile, "makepp_simple_concatenation"ı mümkün olduğunca erken ayarlamak en iyisidir.)
hatta sadece bir hedef için ayarlayın:

hedef: makepp_simple_concatenation = 1
hedef:
&echo Before_first$(LIST)after_last -o $(çıktı)

"$[VARIABLE]", "$(VARIABLE)" öğesinden daha önce değerlendirildiği için, ikisini rc-'de birleştirerek
değiştirme, açık bir şekilde sarmadığınız sürece beklediğiniz sonucu vermeyecektir.
liste:

bir = ab
N = 1 2
KÖTÜ := $(A)$[N]
İYİ := $(A)$( $[N])

Son satırlar şu şekilde okunur

KÖTÜ := $(A)1 2 # a1 b1 2
İYİ := $(A)$( 1 2) # a1 a2 b1 b2

Ikame Referanslar

Bir ikame referansı "$(VAR:A=B)" biçimindedir, burada A eşlenecek bir kalıptır ve B
onu değiştirmek için bir desen. İkame referansları,
"patsubst" işlevi. Örneğin:

kaynak_dosyaları = ac bc cc dc
nesne_dosyaları = $(kaynak_dosyaları:%.c=%.o)

"$(object_files)" öğesini "ao bo co do" olarak ayarlayacaktır. "%" özel bir karakter eşleşmesidir
herhangi bir keyfi dize. Hem A hem de B "%" ile başlıyorsa, değiştirirken yaygın bir durum
son ekler, bunlar atlanabilir:

nesne_dosyaları = $(kaynak_dosyaları:.c=.o)
object_files = $(source_files:c=o) # aynı, çünkü . özel değil

Beyaz boşluk in değişkenler

Bir değişkendeki boşlukları kontrol etmeniz gerekiyorsa, (şu anda) rc stilini devre dışı bırakmalısınız.
ikame ("makepp_simple_concatenation=1" ayarlayarak) ve ardından şöyle bir sözdizimi kullanın:

boş =
T = -o $(boş)

veya boş bir değerlendirme ile:

T = -o $()

Bunu yaptığınızda, "T" değişkeni "-o" ve ardından bir boşluk içerir.

Boşlukları işlemek için bu tür bir teknik önerilmez. Değişkenlere ihtiyacınız varsa
makefile'nizde boşlukları içerecek şekilde, ne yaptığınızı ciddi olarak düşünmelisiniz.
Boşlukları yönetmeniz gerekiyorsa, genellikle Perl kodunu dosyanıza koymak çok daha iyidir.
bununla ilgilenmek için ("perl_begin" veya "sub" ifadelerini kullanarak) veya işlemek için makefile
kuralların eylemlerinde kabuk ifadelerinde.

Bu durumlar tipik olarak, insanlar aynı kuralları farklı durumlar için kullanmaya çalıştığında ortaya çıkar.
tipik Unix komut sözdizimini kullanmayan mimariler. Örneğin, bazen biri görür
makefiles'de bunun gibi şeyler:

ifeq ($(ARCH),garip)
O := /ÇIKTI=
başka
boş :=
O := -o $(boş)
endif

%.o : %.c
$(DERLEME) $(girdi) $(O)$(çıktı)

Bunu gerçekten isterseniz makepp ile yapabilirsiniz, ancak muhtemelen
daha az karmaşık değişkeniniz varsa makefile dosyaları önemli ölçüde daha okunabilir
ikame, örn.

ifeq ($(ARCH),garip)
%.o : %.c
$(WEIRD_COMPILER) $(giriş) /OUTPUT=$(çıktı)
başka
%.o : %.c
$(CC) -c $(girdi) -o $(çıktı)
endif

Değişken adlarında, yalnızca değerlerinde boşluklara asla izin verilmez. Bu farklı
bazılarından uygulamalar yapar.

Otomatik Değişkenler
Otomatik değişkenler, hangi kurala bağlı olarak farklı değerler alan değişkenlerdir.
içinde değerlendirilirler. Makepp, diğer otomatik değişkenlerin çoğunu destekler.
make use sürümleri. Ayrıca, çoğu için daha az şifreli, daha uzun isimler var.
bunun yerine kullanabilirsiniz. (Bu adları yeniden tanımlayan eski makefile dosyaları için,
makefile içindeki tanım, varsayılan anlamı geçersiz kılar. Örneğin, derseniz
makefile dosyanızda "target = abc", ardından "$(target)" her zaman "abc" olarak genişler ve
artık $@ ile eşdeğer olabilir.)

Makepp'in desteklediği tüm otomatik değişkenlerin tam listesi aşağıdadır:

çıktı
hedef
$@ Geçerli kuralın hedefi. Aslında makepp birden çok hedefi desteklediğinden
herhangi bir kural, bu ilk hedef. Örneğin, aşağıdaki kuralda

y.tab.c y.tab.h : ayrıştırıcı.y
$(YACC) -o $(çıktı) $(YFLAGS) $(giriş)

"$(çıktı)" değeri içerecektir y.tab.c. Bu sihirli değişkenler aslında
işlevler, ayrıca bir dizini argüman olarak iletebilirsiniz. Bu 1'den geriye doğru sayılır
1'den. Yani "$(çıktı 2)" veya "$(çıktı -1)" değeri içerecektir y.tab.h.

Bu değişkenin her üç biçimi de aynı değere sahipken, aralarında bir fark vardır.
çok hedefli kuralların yorumlanması. Eski tarz şifreli $@ adını kullanırsanız,
makepp bunu modern bir kuraldan ziyade eski tarz bir kural seti olarak yorumlayacaktır.
tüm bu hedefleri tek seferde üretir:

ab: # gerçekten: a ve b için birer kural
$@'a dokunun

cd: # error: mpp bunun d oluşturmadığından şikayet ediyor
$(çıktı) öğesine dokunun

çıkışlar
hedefler
Geçerli kuralın tüm hedefleri. Birden fazla olmadığı sürece "$(hedef)" ile aynı
hedef. Yukarıdaki örnekte, "$(outputs)" y.tab.c y.tab.h olacaktır. bir geçebilirsin
dizin listesi, yani "$(çıktılar 2 1)" y.tab.h y.tab.c olacaktır.

bağımlılık
giriş
$< Kuralın ilk açık bağımlılığı. Örneğin, bu kuralda

%.o : %.c
$(CC) $(CFLAGS) -c $(girdi) -o $(çıktı)

"$(input)", .c dosya, ne olursa olsun .h dosyalar makepp
keşfeder. Birden fazla bağımlılık belirtirseniz, bunları bir
index: "$(input $(INDEX))" INDEX'inci bağımlılıktır.

bağımlılıklar
girişler
$^ Dahil olmayan hedefin tüm açık bağımlılıkları .h tarafından keşfedilen dosyalar
içermeler için makepp_scanning.

Örneğin, kuralda

prog.o : *.o
$(CC) $(CFLAGS) $(girdiler) -o $(çıktı)

"$(inputs)" dizindeki tüm .o dosyaları olacaktır. sadece kendin olanları seçebilirsin
bir dizin listesi geçirerek istiyorum. Açıkça farklı türde dosyalar belirtirseniz,
onları "$(inputs 2 3 4)" içinde olduğu gibi seçebilirsiniz (ancak bir joker karakterle bu çok değildir
umut verici).

sort_dependencys
sort_inputs
$+ Hedefin tüm bağımlılıkları, sıralı düzende, kopyalar kaldırılmış halde.
"$(sort $(girişler))" ile eşdeğerdir.

change_dependencys
change_inputs
$? Değişen hedefin bağımlılıkları. Bu sadece açık içerir
bağımlılıklar (yani, makefile'de listeledikleriniz), dolaylı olarak keşfedilmemiş
taramadan kaynaklanan bağımlılıklar (.h dosyaları gibi).

Bu genellikle aşağıdaki gibi komutlarda kullanılır:

libmine.a : $(MODULES) : build_check görmezden_eylem
$(AR) ru $@ $?

yani ar yalnızca değişen modülleri değiştirmesi söylenir. (Not:
"ignore_action" derleme kontrol kuralı. Bunu belirtmezseniz, makepp
her değiştiğinde yürütülecek eylem. Hiçbir bağımlılık değişmediyse,
eylem dizesi, muhtemelen olduğundan farklı olan "ar ru libmine.a" olacaktır.
en son çalıştırdığınızda, "ignore_action" olmadan makepp onu çalıştıracaktır. Bunda
durumda, zararsızdır, ancak diğer komutlarda sorun olabilir. Görmek
makepp_build_check "ignore_action" ile ilgili ayrıntılar için.)

Bunun gibi arşivler oluşturmak iyi bir fikir değil çünkü yapılarınızı azaltacaktır.
güvenilir. Bununla ilgili sorun, arşivi oluşturursanız, bunlardan birini kaldırmanızdır.
MODÜLLER listesindeki modüller, modüller hala arşivde olacak ve
makep

kök
$* Bir kalıp kuralındaki kök (yani, '%' neyle eşleşirse eşleşir). Alternatif olarak, eğer bu
bir kalıp kuralı değildir, uzantı olmadan dosya adını döndürür (yani,
"$(taban adı $(input))" ile eşdeğerdir.

Bu çoğunlukla geriye dönük uyumluluk içindir. Örneğin, eski sürümlerde make the
herhangi bir şeyi nasıl derleyeceğini söylemenin tek yolu .c ilgili dosyaya .o dosya gibiydi
bu:

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

Bu, kuralı yazmanın berbat bir yolu. GNU yapımı stilini kullanmak çok daha net
desen kuralları, bunun gibi:

%.o : %.c
$(CC) $(CFLAGS) -c $(girdi) -o $(çıktı)

her biri için
"foreach" yan tümcesindeki geçerli dosya adı. "foreach" cümleleri nadiren kullanılır,
ancak makepp'in desteklediği en genel amaçlı kalıp kuralı türüdür. İçin
örnek,

#
# Bir tür özel önişlemci ile .c dosyaları oluşturun:
#
%.c : %.k
$(önişlemci) $(girdi) > $(çıktı)

#
# .c dosyalarını .o dosyalarına derleyin:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(girdi) -o $(çıktı)

#
# Türetilmiş .c dosyaları için özel alternatif derleme bayrakları
# .k dosyalarından:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(girdi) -o $(çıktı)

Daha fazla ayrıntı ve örnek için kurallardaki foreach maddesiyle ilgili belgelere bakın.

$/ Bu aslında bir sabittir, ya "/" ya da yerel Windows "\" üzerinde. Eğer ihtiyacın varsa
bir programı taşınabilir olarak başlatmak istiyorsanız, örneğin geçerli dizinde oluşturduğunuz bir program:

çıktılarım:
.$/prog >$(çıktı)

Bağımsız değişken olarak iletilen dosya adları için, Windows Unix'i işleyebileceğinden çok gerekli değildir.
sözdizimi var.

seçenek Değişkenler
Bunları değiştirmek için yukarıda açıklanan tüm şekillerde (aksi belirtilmedikçe) ayarlayabilirsiniz.
makepp davranışı. Varsayılan olarak hepsi tanımsızdır.

MAKEPP_DEBUG
Makepp'i çağırmadan önce bunu gerçek bir değerle dışa aktarırsanız, daha fazla hata ayıklama elde edersiniz.
bilgi. Bu, yürürlükteyken oluşturulan dosyaların "RULE_SOURCE" öğesidir.
makeppinfo, mppi ve altında değişken genişletme ve kural eşleştirme hakkında ayrıntılar
makepplog, mppl. Bu ayrıca, makepp'in belleğinin tükenip bitmediğini veya kilitlenip kapanmadığını size gösterecektir.
çünkü aynı değişkenleri sonsuza kadar genişletiyor:

A = $A # ertelenmiş değerlendirme, ihtiyaç :=
B = $C
C = B $

MAKEPP_LN_CP
&ln altındaki nota bakın.

makepp_percent_subdirs
Hedeflerde veya bağımlılıklarda "%" olması için bunu gerçek bir değere (1 gibi) ayarlayın
birden fazla dizinde.

makepp_require_phony
Örtük sahteliği önlemek için bunu gerçek bir değere (1 gibi) ayarlayın (yani bir kural varsa
hedefini üretmeden başarılı olur). Bu değişken varsayılan olarak true olmalıdır,
kırık bağımlılık zincirlerini önler, ancak bu, geriye dönük uyumluluğu bozar
özensiz makefiles.

makepp_signature_C_flat
Bu, C'yi imzalamak için bir seçenektir.
düzleştirilmiş kaynaklar, yani tüm yeni satırlar (önişlemci deyimleri dışında)
boşluk gibi işlem görür ve "#line" yönergeleri yoksayılır.

makepp_simple_concateration
"RC tarzı ikameyi" önlemek için bunu gerçek bir değere (1 gibi) ayarlayın.

PERL
Bunu, makepp'te komut dosyalarını çalıştırmak için kullandığınız tam perl'e ayarlayabilirsiniz.
paketi ve dışa aktarın. Bu, aynı Perl ile alt betikleri çalıştırmaya yardımcı olabilir. Bu
çoğunlukla test paketi, kurulum ve özyinelemeli yapılar için kullanışlıdır.

VPATH
Bu değişkeni bir değere ayarlamak, dolaylı olarak "vpath % değeri"ni çağırır.

Önceden tanımlanmış Değişkenler
Makepp, geçersiz kılabileceğiniz birkaç değişkeni önceden tanımlar:

AR Varsayılan: "ar".

ARFLAKLAR
Varsayılan: "rv".

AS Varsayılan: "olarak".

CC Varsayılan: İlki "gcc", "egcc", "pgcc", "c89" veya "cc" arasında veya Windows'ta bulundu
ayrıca "cl" veya "bcc32".

FLAG'LAR
Varsayılan: "$(CC)" bir GNU derleyicisi "-g -Wall" ise, iki Windows'tan biriyse
derleyiciler hiçbir şey, başka "-g".

KÜRDÜR
Geçerli Makefile dosyasının bulunduğu dizin.

CXX Varsayılan: İlki "g++", "c++", "pg++", "cxx", "C""C" veya "aCC" arasında veya üzerinde bulunan
Windows ayrıca "cl" veya "bcc32".

CXXFLAG'LAR
Varsayılan: "$(CXX)" bir GNU derleyicisi "-g -Wall" ise, iki Windows'tan biriyse
derleyiciler hiçbir şey, başka "-g".

F77 Varsayılan: İlki "f77", "g77" veya "fort77" arasında bulunur.

FC Varsayılan: "$(F77)".

LD Varsayılan: "ld".

LEX Varsayılan: İlk "lex" veya "flex" arasında bulundu.

LIBTOOL
Varsayılan: "libtool".

YAP
Bu değişkenin olup olmamasına göre iki farklı değeri vardır.
"--geleneksel-özyinelemeli-yapım". Makepp, bu değişkenin ne zaman kullanıldığını tanır ve
özyineleme gerçekleşmeden önce bile bazı özellikleri kapatır. Bu olabilir
yavaş yavaş ortadan kaldırırken istenmeyen bir durumdur, bu nedenle önce aramaları bir
özellikleri kapatmayan makepp'e özgü "$((MAKE))". onu ayarlamamalısın
çünkü bu bizim akıllı özyineleme çalışmamızı bozar.

MAKECMDHEDEFLER
Bu değişken ayarlanır ancak makepp tarafından kullanılmaz. Bir şey yapmak için sorgulayabilirsiniz, ancak
belli bir hedef istendi.

Varsayılan: Açık olan ne olursa olsun, sağlanan kullanıcıyı (veya yinelemeli bir çağrıyı) hedefler.
Örtülü olarak varsayılan hedef oluştururken boş.

ifneq $(özel hedefi filtrele, $(MAKECMDGOALS))
# özel hedef, mevcut açık hedeflerden biridir
başka ifeq $(MAKECMDGOALS)
# açık hedef yok
endif

MAKEFLAGS (ihracat)
Makepp'in çağrıldığı standart seçenekler. Tek harfli olanlar
form başında "-" olmadan birleştirilir (cennet bilir neden gmake'i seçtiğini
"-" bırakmak için).

YAPI BİLGİSİ
Varsayılan: "make bilgisi".

MAKEPPFLAGS (ihracat)
Bu, MAKEFLAGS ile aynı değere ayarlanır, ancak yalnızca bu değişken
makepp'in ortamı.

_MAKEPPFLAGS (dışa aktarıldı)
Makepp ile POSIX/gmake uyumluluğu için gereken makepp'e özgü seçenekler
aradı. Bunlar ayrı bir değişkendedir, bu nedenle eski bir makefile bozulamaz
MAKEFLAGS ayarını kaldırarak uyumluluk. Bu sadece ile ayarlanır
"--geleneksel-özyinelemeli-yapım".

MAKEP_VERSION YAPIN
Çalıştırdığınız makepp sürümü. Eğer bir beta sürümü ise, bir
tire ve ardından YYMMDD artı biraz daha dahili veri. Bunu "ifdef" için kullanabilirsiniz
makepp'e özgü yapıları diğer markalardan gizlemek için.

Varsayılan: "makepp --version" tarafından görüntülenen aynı değer

PWD "CURDIR" için bir takma ad.

RM Varsayılan: "rm -f". Bu, eski Makefile'ler içindir. Yeni olanlar için tercihen kullanın
doğrudan yerleşik &rm komutu. Sahte bir temiz kural yazmak istiyorsanız, şuna bakın:
bunun yerine "makeppclean -r" komutu.

KÖK
Derleme sisteminizin kök dizinine göreli yol, yani dizin
hangi bir "RootMakeppfile(.mk)" var. Eğer bir tane yoksa, bu değişken
boş.

SHELL
Bu değişkene yalnızca "dışa aktarırsanız" saygı duyulur. Bu durumda Shell
içinde bazı özel karakterler bulunan yerleşik olmayan eylemleri yürütmek için kullanılır (düz
doğrudan yürütülenler). Windows Strawberry veya ActiveState Perl'de, varsa
Unix benzeri bir Kabuk, bunun yerine SHELL değişkeninizi "sh" ile biten bir değere ayarlamanız gerekir.
veya "sh.exe" önce makepp'i çağırıyor.

Varsayılan: İlki "/usr/xpg4/bin/sh" (örn. Solaris) veya "/sbin/xpg4/sh" arasında bulunur
(örn. Reliant Unix) veya "/ Bin / sh".

YACC
Varsayılan: İlk "bizon -y" veya "yacc" arasında bulundu.

Değişkenler ve Perl
Değişken değerler sıradan Perl skalerleri olarak depolanır, böylece onlara doğrudan şuradan erişebilirsiniz.
Onlarla herhangi bir karmaşık işlem yapmanız gerekiyorsa, Perl kodu; makepp_extending'e bakın
Ayrıntılar için.

Perl'den global değişkenlere erişim, onlara "Mpp::global" ön eki getirilerek elde edilir.
paket. Aslında, mevcut makefile'de henüz mevcut olmayan ve sizin istediğiniz herhangi bir değişken
bu pakette atama, o andan itibaren, sanki yeni yayınlamışsınız gibi global olacaktır.
bunun için "küresel" bir açıklama.

Ancak bu doğrudan erişim hataya açıktır! Kullanıcı bu değişkenleri geçersiz kılmış olabilir
komut satırında veya ortam aracılığıyla. Bundan önce yüklenen başka bir makefile
değişkeni global veya hedefe özel yapmış olabilir. Bu durumlarda yapmazsın
değişkenin değerini bulun veya onu atadığınızda özelliğini ortadan kaldırabilir
(hedef özellikleri dışında bir "geçersiz kılma" değiştiricisine eşdeğerdir.)

Doğrudan erişimle, eğer türdeyse bu değişkenlerin genişletilmesini de atlarsınız.
"=" veya ";=". "$(CC)" gibi özel değişkenler, işlev olarak başlarlar.
atandı. Bu yüzden çoğu durumda onların değerini görmezsiniz.

Bu nedenlerle, makepp'in doğru değeri belirlemesine izin vermek daha iyidir. kullanabilirsiniz
Perl kodu alınmadan önce değişkenin değerlendirildiği "makeperl" varyantı
yorumlandı:

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

Makefile Perl bloklarında bir değişkene ihtiyacınız varsa, bu Perl değişkeni aracılığıyla elde edilir.
$makefile aşağıdaki gibi:

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

İşlevler her zaman makefile nesnesini ikinci argüman olarak $_[1] olarak iletir:

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

Komutların, makefile nesnesinin olduğu bir kural eylemi içinde çağrılması gerekir.
"$Mpp::Subs::rule->{MAKEFILE}" yoluyla erişilebilir:

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

onworks.net hizmetlerini kullanarak makepp_variables çevrimiçi kullanın