makepp_rules - Bulutta Çevrimiçi

Program:

ADI

makepp_rules -- makepp'e bir şey inşa etmesi nasıl söylenir

TANIM

?: &,
-,
@, B: :build_cache,
:build_check, D: :sevk etmek, E: :env, I: "ignore_error",
:Dahil etmek, L: :son şans, M: yapıcı, N: "noecho", P: : ayrıştırıcı,
"perl", S: :imza

Bir kural, makepp'e bir dosyanın veya bir dosya sınıfının nasıl oluşturulacağını söyleyen şeydir. Makepp şunları destekler:
diğer make uygulamalarıyla aynı kural sözdizimi ve ayrıca kendi eklemeleri.

Bir kuralın genel biçimi vardır

target_expression : bağımlılık_ifadesi [ : isteğe bağlı bağımsız değişkenler]
eylemler

Hedefler listesi herhangi bir otomatik değişken içeremez ("$(foreach)" dışında). NS
bağımlılık listesi yalnızca hedefe atıfta bulunan otomatik değişkenler içerebilir (örn.
"$(çıktı)", "$(çıktılar)" veya eşanlamlıları). Eylem, herhangi bir otomatik
değişkenler.

Makepp, kuralın yürütülmesi gerektiğine karar verirse, kuralın her satırı yürütülür.
sırayla ve herhangi biri sıfır olmayan bir durum döndürürse, kalanlar yürütülmez (ve
makepp, komut satırında "-k" seçeneğini belirtmediğiniz sürece bir hatayla iptal olur.)
Her eylem yalnızca bir satır olmalıdır. Bir eylem, uygun bir şekilde yazmak için çok uzunsa
tek satır, onu birkaç satıra bölebilir ve ters eğik çizgi koyabilirsiniz.
birkaç satır tek bir satırda birleştirilmelidir.

Eylemleri bir sonraki kuraldan ayırt etmek için eylem daha fazla girintili olmalıdır.
hedefleri ve bağımlılıkları içeren satırdan daha fazla. Diğer uygulamalardan farklı olarak
make, makepp, ne kadar girinti yaptığınızı veya sekme karakterlerini kullanıp kullanmadığınızı gerçekten umursamıyor
boşluklardan ziyade. Geleneksel markayla geriye dönük uyumluluğu korumak için kurallar
makepp eylemlerin ne zaman biteceğine ve bir sonraki kuralın ne zaman başlayacağına karar vermek için kullanır:

· İlk eylem satırı, hedefi içeren satırdan daha fazla girintili olmalıdır.

· Bir satırda bir sekme karakteri veya 8 veya daha fazla boşluk varsa, o zaman kabul edilir
bir eylem hattı.

· Boş bir satır veya sağ kenarda "#" karakteri olan bir yorum satırı,
kural, bir sonraki boş olmayan satır 8 boşluktan (veya birden fazla) girintili değilse
sekmesi).

· Bir satır, ilk eylem satırı kadar veya daha fazla girintiliyse, o zaman
ek bir eylem hattı olarak kabul edilir.

Birkaç özel eylem öğesi vardır:

& Bu sembolün ardından bir komut adı ve herhangi bir sayıda argüman gelmelidir. Kabuk
sözdizimi burada tam olarak anlaşılmadı, yalnızca tek ve çift tırnak ve ters eğik çizgi
makepp boyunca olduğu gibi içindeki karakterler. Komut adı ya bir işleve yol açar
"C_isim" kalan dizelerle argüman olarak çağrılacak. Eğer böyle bir fonksiyon
bulunamazsa, bu bir "Perl" bloğundan "run" çağrısı yapmakla aynıdır.

Bu, yerleşik, makefile tarafından sağlanan veya harici bir komutu verimli bir şekilde çağırmayı sağlar.
"&" ön eki, Perl'deki işlev çağrıcısı olduğu için seçilmiştir ve
başlangıçta Shell'de yasa dışıdır.

$(ROOT)/include/%.h: %.h
&ln $(girdi) $(çıktı)

yankı yok
@ Normalde, her kabuk komutu yürütülürken yazdırılır. Ancak, eğer ilk kelime
eylem "noecho" ise (veya "@" karakteriyle başlıyorsa), o zaman komut
yazdırılmaz. Örneğin,

%.o: %.cxx
noecho $(LIBTOOL) --mode=derleme $(CC) -c $(girdi)

Bu, libtool komutu yürütüldüğünde yazdırılmadığı anlamına gelir. (Libtool
kendisi genellikle yürüttüğü değiştirilmiş komutu yazdırır, bu nedenle gereksizdir
iki kez yazdırın.)

görmezden_hata
- Normalde, kabuk komutu sıfırdan farklı bir durum döndürürse makepp iptal olur çünkü
komut başarısız oldu. Ancak, bazı programlar çıkışta durumu yanlış ayarlar veya
gerçekten ölümcül olmayan ve tamamını iptal etmemesi gereken bir hata olabilir
derleme. belirterek makepp'in dönüş durumunu yok saymasını sağlayabilirsiniz.
Komut satırının ilk sözcüğü olarak "ignore_error" (veya ilk karakter olarak "-").
Örneğin,

$(sahte dağıtım):
görmezden_error rm -r my_program-$(VERSION) # Önceki gereksizlerden kurtulun.
&mkdir my_program-$(VERSION)
&cp $(DOSYALAR) my_program-$(VERSION)
tar cf my_program-$(VERSION).tar my_program-$(VERSION)

Bu komut bir dizin oluşturur, içine bir sürü dosya kopyalar ve ardından
dağıtım için her şeyi bir tar dosyasına. temizlemek iyi bir fikirdir.
dizinin önceki içeriği, daha önce orada bir şey varsa ve bu
ilk satır ne işe yarar "rm" başarısız olabilir, ancak dönüş durumu yok sayılır.

perl
yapıcı
Bu aslında Perl deyimiyle aynıdır, ancak her seferinde gerçekleştirilir.
makefile okurken değil, kuralı çalıştırırken. İlk varyant düz Perl'dir.
kodu, ikinci varyant ise ifadeyi ilk önce Make-style değişkeninden geçirir.
genişleme.

Vücudun parantezlerini takmanın iki olasılığı için, aşağıdaki açıklamaya bakın.
makepp_statements içindeki "perl_perlcode". Üçüncü varyantın orada açıklandığına dikkat edin.
burada hiçbir anlam ifade etmiyor, çünkü tüm eylem satırları girintili olmalıdır. sinyal vermelisin
Perl ifadelerinde "öl" diyerek başarısızlık.

Kural başına, Perl deyimleri şu anda aşağıdakiler dışında ortak bir alt süreçte değerlendirilir:
Pencereler. Bu, herhangi bir makefile değişkenine yalnızca okuma erişimine sahip oldukları anlamına gelir. Aynı zamanda
Perl dışı eylemleri yürüten süreç. Bu yüzden exec veya çıkış çağırmak kafa karıştırır
makep. Ama bu gelecekte değişebilir. Perl'i aramanın verimli bir yolu için
komut dosyaları için önceki "&" veya "çalıştır" öğesine bakın.

$(sahte sürüm):
noecho perl Perl'den {{ # $(hedef) & $(VERSION):
print "Bu ".f_target()." $VERSION\n";
}}
echo Bunu Shell komutlarıyla karıştırabilirsiniz.
-makeperl { print "Bu $(hedef) $(VERSION)\n" }

Her biri farklı amaçlara sahip birkaç farklı kural türü vardır.

açık kurallar
hedef1 hedef2: bağımlılık1 bağımlılık2 ...
yapılacak işlemler

Bu sözdizimi, aşağıdakilerden birini yapmak için şunları belirtir: hedef1 or hedef2, tüm dosyalar
bağımlılık1, bağımlılık2vb. zaten yapılmış olmalıdır. Daha sonra verilen eylemler
hedefleri yapmak için kabuk tarafından yürütülür.

Bir dosyadaki ilk açık kural varsayılan hedeftir ve belirtmezseniz yapılır.
komut satırındaki herhangi bir hedef.

Geleneksel make programlarından farklı olarak makepp, genellikle eylemin bir kez çağrıldığını varsayar.
tüm hedefleri yapar (bağımlılık olmadığı sürece). Örneğin, bir çağrı
of yacc, bu kural için her iki çıktı dosyasını da oluşturur:

y.tab.c y.tab.h : ayrıştırıcı.y
$(YACC) -d ayrıştırıcı.y

Diğer make uygulamalarının tek bir komut kavramına sahip olmadığını unutmayın.
birden çok çıktı dosyası üretir ve böylece birden çok hedef belirlediğinizde bunlar
kuralı hedef başına bir kez yürütün. Makepp, şuna benziyorsa bu davranışa geri dönecektir.
bu eski tarz bir makefile. Spesifik olarak, kuralı hedef başına bir kez yürütür,
Aşağıdakilerin tümü doğruysa, genel olarak yalnızca bir kez yerine:

· Kural eylemi $@ otomatik değişkeninden bahseder. ("$(çıktı)" eşanlamlıları veya
"$(target)" bu davranışı tetiklemez.)

· Kural eylemi "$(outputs)" otomatik değişkeninden (veya eşanlamlısından) bahsetmez.
"$(hedefler)").

· Bu bir kalıp kuralı değildir ve foreach maddesi yoktur.

Örneğin,

tüm test kurulumu:
$(SUBDIRS) içindeki alt dizin için; do cd $$subdir && $(MAKE) $@; cd..; tamamlamak

makefiles'de yaygın bir deyimdir ve makepp bunu destekler. (Asla kullanmamanız gerektiğini unutmayın.
yazdığınız herhangi bir yeni makefile'de özyinelemeli make -- "load_makefile" ifadesini kullanın veya
bunun yerine örtük makefile yükleme.)

Her hedef için aynı kuralın bir kez yürütülmesini istiyorsanız (örn.
benzer komutlara sahipseniz), bir model kuralı (aşağıya bakın) veya bir
"foreach" maddesi. Örneğin, geleneksel bir make programıyla şunu yazarsanız:

abcd:
$@ > $@ oluşturmak için do_something

makepp'te muhtemelen şöyle yazmak istersiniz:

$(foreach) : : foreach abcd
$(çıktı) > $(çıktı) oluşturmak için do_something

Sahte hedefler

A sahte hedef dosya sisteminde asla var olmayacak bir hedeftir; bu sadece bir
makepp'in bazı hedefler oluşturmasını ve muhtemelen bazı ek komutları yürütmesini sağlamanın yolu.

Tipik bir sahte hedef, genellikle olabilecek her şeye neden olmak için kullanılan "tümü"dür.
inşa edilmek üzere inşa edildi, şöyle:

tümü: prog1 prog2 altdizini/prog3 altdizini2/libmine.a
@&echo "Her şey bitti!"

"makepp all" yazarsanız veya makefile'nizdeki ilk açık hedef olarak all koyarsanız
(tipik olan) ve sadece "makepp" yazın, o zaman tüm bağımlılıkların
oluşturulduktan sonra "Hepsi tamamlandı!" yazdıracaktır. Bu noktada makepp dosyayı arayacaktır. ./herşey
ve var olmadığını keşfedecek. Yüksek sesle şikayet edecek.

makepp'in dosyayı beklemesini önlemek için ./herşey çıkmak için, bunun bir
sahte hedef. Makefile dosyanıza aşağıdaki gibi bir satır koymanız yeterli
nerede):

.PHONY: hepsi

Bazen daha uygun olan eşdeğer bir alternatif "$(phony )" kullanmaktır.
işlevi, bunun gibi:

$(hepsi sahte): prog1 prog2 altdizini/prog3 altdizini2/libmine.a

Bir makefile içindeki sahte hedefler, başka bir makefile içindeki sahte hedeflere başvurabilir. Bu
genellikle "temiz" hedefle yapılır, şöyle:

# Üst düzey makefile:
# burada birçok kural ve malzeme
# ....
$(sahte temizlik): altdizin1/temiz altdir2/temiz
&rm -fm benim_programım

Daha sonra alt dizinlerde makefile dosyaları şöyle okunabilir:

# Makefile bir alt dizinde
#...
$(sahte temizlik):
&rm -fm $(joker karakter *.o *.a)

Ancak günümüzde temiz bir hedef yerine "makeppclean" komutunu kullanırsınız.

Joker karakterler

Bağımlılık listesinde joker karakterler belirtmek güvenlidir. Joker karakterler yalnızca dosyalarla eşleşmez
var, ancak makefile içindeki kurallar verildiğinde oluşturulabilecek dosyalar. Örneğin,
bir dizindeki tüm .o dosyalarından bir kitaplık oluşturmak için şunu yazabilirsiniz:

libmine.a: *.o
&rm -f $(çıktı)
ar cr $(çıktı) $(girdiler)

Bu, ".o" dosyalarından hiçbiri henüz oluşturulmamış olsa bile çalışır, çünkü makepp'ler
joker karakterler henüz var olmayan ancak oluşturulabilen dosyalarla eşleşir. Bu bile alacak
kuralı daha sonra keşfedilen dosyalar (aynı makefile içinde veya henüz okunmamış). Bunda
son nokta, bilinen kurallarla sınırlı olan "joker karakter" işlevinden farklıdır,
çünkü genişletildiğinde sonucunu döndürmesi gerekir.

Makepp, tüm olağan kabuk joker karakterlerini ("*", "?" ve "[]") destekler. Ayrıca bir
Herhangi bir sayıda araya giren dizinle eşleşen joker karakter "**". (Bu fikir çalıntı
zsh'den.) Örneğin, "**/*.c", tüm .c tüm kaynak ağacındaki dosyalar.
"objects/**/*.o" tüm öğelerle eşleşir .o alt dizinde herhangi bir yerde bulunan dosyalar nesneler
veya alt dizinlerinden herhangi biri veya alt dizinlerinden herhangi biri. "**" joker karakteri
herhangi bir düzeyde dizinlere yumuşak bağlantıları izleyin. Ayrıca asla sahte hedefler döndürmez.

Makepp'in joker karakterleri, var olan ancak okunamayan dosyaları veya dizinleri yok sayar. Sonrasında
tüm, bu tür dosyalar zaten derleme sürecinde kullanılamaz. Okunamayan dosyaları bir dosyaya koymak
dizin, verilen dosyanın otomatik olarak içe aktarılmasını engellemek için öncelikle yararlıdır.
deposu.

İlk iddia, bunun güvenli olduğuydu. Bu, işe yarayıp yaramadığı anlamında
dosyalar zaten var veya önce oluşturulmaları gerekiyor. Ancak bu anlamda güvensiz
makepp tarafından oluşturulmuş ancak artık bir kuralı olmayan dosyalarla eşleşmeye devam edeceğini (örn.
sen kaldırdın .c dosya, ancak .o dosya hala orada.) Bunu önlemek için
"--rm-eski" seçeneği.

model kurallar
Bir kalıp kuralı, bazı metinsel kalıplara dayalı olarak uygulanan bir kuraldır. Bu kullanılır
aynı kuralı tüm dosya sınıfına uygulayın. Sözdizimi GNU make'ninkiyle aynıdır.
desen kuralları:

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

Bu, geçerli dizindeki "*.c" ile eşleşen herhangi bir dosyanın dönüştürülebileceğini söylüyor.
verilen komutu kullanarak karşılık gelen .o dosyası.

Birkaç desen bağımlılığının sağlanabileceğini unutmayın. Örneğin, eğer xyz.o dosya
karşılık gelen bağlıdır xyz.cpp dosyasında ve ayrıca adı verilen bir dosyada moc_xyz.cflags hangi
derleyici seçeneklerini içerir, bu şu şekilde ifade edilebilir:

%.o: %.cpp %.cflags
$(CXX) `cat $(stem).cflags` -c $(girdiler) -o $(çıktı)

Ayrıca birkaç desen hedefiniz olabilir. Örneğin,

%.tab.h %.tab.c : %.y
yacc -d $(girdi)
&mv y.tab.h $(stem).tab.h
&mv y.tab.c $(stem).tab.c

Normalde, kalıp kuralları yalnızca geçerli dizinlerdeki dosyaları arar. zorlayabilirsin
ayarlayarak geçerli dizinde ve altındaki tüm dizinlerde arama yapmaları

makepp_percent_subdirs := 1

örneğin makefile'nizdeki veya komut satırındaki ilk kalıp kuralından önce.

"%" ve joker karakter "*" arasında açık bir fark vardır, ancak ikisi de herhangi biriyle eşleşir.
string: Joker karakter, o noktada tamamen kullanılan dosyaların bir listesini döndürür. Yani
bu her şeye bağlı .o burada oluşturulabilir dosyalar:

program: *.o
$(LD) $(LDFLAGS) $(girdiler) -o $(çıktı)

Bu, "*" yerine "%" yazılarak gerçekleştirilemez, çünkü ikincisi birer birer içindir
girdi ile çıktının eşleştirilmesi, eşleşen her gövde için dahili olarak bir kural üretilmesi.

Statik model kurallar
Statik kalıp kuralı, yalnızca sınırlı sayıda dosyaya uygulanan bir kalıp kuralıdır:

$(SPECIAL_MODULES).o : %.o : %.cpp
$(CXX) -c $(girdi) -o $(çıktı)

Bu, kalıp kuralının yalnızca "$(SPECIAL_MODULES).o" içindeki dosyalar için geçerli olduğunu söyler.

Bu çoğunlukla GNU markasıyla uyumluluk içindir; foreach kuralları (aşağıya bakın) daha
aynı şeyi yapmanın güçlü yolu.

Her biri için kurallar
Yukarıdaki kalıp kuralı sözdizimi, hemen hemen tüm yapıları destekleyecek kadar güçlüdür, ancak
bazen daha karmaşık bir şey yapmak gerekir. Makepp daha fazlasını sağlar
güçlü sözdizimi: kural için ":foreach" yan tümcesi.

target_expression : bağımlılık_ifadesi : foreach dosya listesi
eylemler

En basit foreach kuralı türü, uygulaması kısıtlanmış bir kalıp kuralıdır.
belirli bir dosya listesine. Örneğin, şunu söyleyen bir kalıp kuralınız olduğunu varsayalım:
makepp nasıl derlenir .c Dosyalar. Ancak, bir listeniz var .c hangi dosyalar için
farklı bir şey yapmak istiyorum. Bunun gibi bir şey yapabilirsin:

# İşte her şey için geçerli olan kural:
%.o : %.c
$(CC) $(CFLAGS) -c $(girdi) -o $(çıktı)

%.o : %.c : foreach $(SPECIAL_MODULES)
$(CC) $(SPECIAL_CFLAGS) -c $(girdi) -o $(çıktı)

Foreach kurallarının daha da güçlü bir şekilde kullanılması, değişkenin
"$(foreach)" sırayla dosya listesiyle ve hedefle eşleşen her dosyaya ayarlanır ve
bağımlılık ifadeleri değerlendirilir. Dosya listesi joker karakterler içerebilir ve bunlar
henüz var olmayan ancak oluşturulabilen dosyaları bile eşleştirin (bkz.
makepp_rules).

Bu hantal bir sözdizimidir ancak son derece esnektir, çünkü "$(foreach)" değişkeni
ifadede herhangi bir şekilde görünebilir. İlk olarak, örüntü kurallarının aslında bir
foreach kurallarının özel durumu; desen kuralı

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

tam olarak şuna eşdeğerdir:

$(patsubst %.c, %.o, $(foreach)) : $(foreach) : foreach *.c
$(CC) $(CFLAGS) -c $(girdi) -o $(çıktı)

(Aslında, dahili olarak yaklaşık olarak buna dönüştürülür.)

Bir kalıp kuralının olmadığı bir ":foreach" yan tümcesini nasıl kullanacağınıza bir örnek olarak
yeterli, varsayalım ki biraz .c bir tür önişlemci kullanılarak oluşturulan dosyalar
hangi bir ile giriş dosyaları olarak alır .k uzantı. Bunları derlemek istiyorsun .c ile dosyalar
normalden farklı derleme seçenekleri seti .c sıradan kaynak olan dosyalar
Dosyalar. Bunun gibi bir şey yapabilirsin:

# Sıradan .c dosyaları için kural:
%.o : %.c
$(CC) $(CFLAGS) -c $(girdi) -o $(çıktı)

# .k dosyalarından .c dosyaları oluşturma kuralı:
%.c : %.k
$(önişlemci) $(girdi) > $(çıktı)

# .k dosyalarından yapılan .c dosyaları için özel derleme kuralları:
$(foreach:%.k=%.o) : $(foreach:%.c=%.k) : foreach *.k
$(CC) $(SPECIAL_CFLAGS) -c $(girdi) -o $(çıktı)

(Bu, çağırmak yerine biraz daha özlü ikame referans sözdizimini kullanır.
açıkça "patsubst".)

Tek yapmak istediğiniz bir değişkenin değerini değiştirmekse ("CFLAGS" bu
durum) bazen hedefe özel değişkenleri kullanmak daha uygundur.

miras sonek kurallar
Geriye dönük uyumluluk için makepp eski tarz son ek kurallarını destekler.

.sonek1.sonek2:
eylemler

eşdeğerdir

%.sonek2: %.sonek1
eylemler

ama hatırlamak çok daha zor. (Hangi son ek önce gelir?) Genellikle bir kural görünür
bunun gibi eski bir makefile'de:

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

tam olarak eşdeğer olan

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

çelişkili kurallar
Bir dosya oluşturmanın birden fazla yolu olduğunda, makepp basit bir prosedür kullanır.
Hangi kuralın kullanılacağını belirleyin.

· Bir dosya oluşturmak için çelişen açık kurallara sahip olmak bir hatadır.

· Kalıp kuralları ve joker karakterli foreach kuralları asla açık kuralları geçersiz kılmaz. Böylece
açık kurallar, kalıp kuralları için istisnaları belirtmek için kullanılabilir. (Sadece şunu unutmayın
":foreach" yan tümcesi kullanmak, bir şeyi kalıp kuralı yapmaz. sahip olması gerekir
":foreach" yan tümcesindeki dosya adının bir parçası olarak joker karakter ("*" veya "?" gibi). Eğer öyleyse
yalnızca açık bir dosya listesi, bunların her biri için açık bir kural olarak kabul edilir.
Dosyalar.)

· Çakışan kalıp kuralları farklı makefile'lerden geldiğinde, kurallar "daha yakın"dan
makefiles, "daha uzak" makefile'lerden gelen kuralları geçersiz kılar. "Daha yakın", makefile
dizin hiyerarşisinde hedefe daha yakın bulunur (yani,
makefile dosyasının çalıştırıldığı dizine göre hedef daha kısadır). Eğer bu
makefiles'i, ardından kuralı yüklenen makefile'den ayırt etmez
en son kullanılır.

Bu, dosyanızdaki tüm dosyalar için geçerli olan bir kalıp kuralı belirtebileceğiniz anlamına gelir.
dizin ağacının tamamı yalnızca üst düzey makefile'de, ancak daha sonra onu geçersiz kılabilirsiniz.
daha düşük seviyeli bir makefile. Örneğin, üst düzey makefile'niz şunları içerebilir:

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

ve alt dizinlerden birinde şöyle yazan bir makefile'niz olabilir:

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

· Daha kısa bir çıkarım zincirine sahip örüntü kuralları, diğer örüntülere göre tercih edilir.
tüzük. Örneğin, aşağıdaki kurallara sahipseniz (bir örneğe dayanarak):
Linux çekirdeği):

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

%.işletim sistemi
$(AS) $(girdi) -o $(çıktı)

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

"xyz.o" oluşturmamız gerekiyorsa, ara ".s" dosyasını oluşturabiliriz ve sonra
ilk iki kuralı kullanarak bunu montajcıdan geçirin, yoksa doğrudan bir
".o" dosyası son kuralı kullanarak. Daha az olduğu için son kural tercih edilir.
çıkarım zincirindeki adımlar (iki yerine bir).

· Makefile'de daha sonra bulunan kalıp kuralları, daha önceki kalıp kurallarını geçersiz kılar. (Bu
GNU make'den geriye doğru.) Bu, daha genel kurallarınızı koymanız gerektiği anlamına gelir.
daha önce ve daha spesifik kurallarınız daha sonra. Örneğin,

%.o: %.c # Genel derleme kuralı.
aksiyon

special_%.o: special_%.c # Bir dosyaya sahip dosyalar için özel kural
farklı eylem # "özel_" öneki.

Kural seçenekleri
Bazen makepp'in aşağıdakileri nasıl yürüteceğini değiştirmek için ek seçenekler sağlamak gerekir.
kural. Bu seçenekler ":optionname value" olarak belirtilir, ya aşağıdakileri içeren satırda:
bağımlılıklar veya bir sonraki satırda.

Seçeneklerin ayrı hatlarda verilmesi, aynı hattı kullanmanıza olanak sağlayabilir.
makepp ve geleneksel bir marka ile makefile. Örneğin,

hedef: bağımlılıklar
: imza target_newer
eylemler

": imza" satırını yorumladığı için geleneksel bir Unix markasıyla iyi çalışır
bir kabuk komutu olarak ve iki nokta üst üste ile başlayan bir komut hiçbir şey yapmaz.

:build_cache /path/to/build/önbellek
hedef: bağımlılıklar
: build_cache /put/cache/files/orada/orada
eylemler

Bu kural tarafından üretilen dosyalar için kullanılacak bir derleme önbelleğinin yolunu belirtir. Bu
"build_cache" ifadesinin veya "--build-cache" komutunun etkisini geçersiz kılar
bu kural için varsa satır seçeneği. Derleme hakkında ayrıntılar için makepp_build_cache bakın
önbellekler.

Yol yerine "hiçbiri" belirtirseniz, bunun için derleme önbelleğini devre dışı bırakırsınız.
özel kural. Bu, oluşturduğunuz dosyalarda disk alanı israfını önlemek için yararlı olabilir.
bilmek, önbelleğe almak için yararlı değildir, çünkü asla olmayacaklarından çok eminsinizdir.
yeniden kullanılmaları veya çok hızlı oluşturuldukları için onları önbelleğe almaya değmez.

:build_check build_check_method
hedef: bağımlılıklar
: build_check hedef_yeni
eylemler

Bu, makepp'e hedeflerin yeniden oluşturulması gerekip gerekmediğine karar vermek için hangi algoritmayı kullanacağını söyler.
Daha fazla ayrıntı için makepp_build_check'e bakın. Bu, aşağıdakilerin etkisini geçersiz kılar:
için "build_check" ifadesi veya varsa "--build-check-method" komut satırı seçeneği
bu kural.

:env DEĞİŞKEN ...
Adlandırılmış ortam değişkenlerinin değerlerine bir bağımlılık ekleyin. eğer bunlardan herhangi biri
önceki yapıdan farklıysa, hedefler güncelliğini yitirmiş olarak kabul edilir.
build_check yöntemi öyle dikte eder. (Aşağıdakiler dışında tüm yerleşik derleme kontrol yöntemleri
target_newer buna saygı duyar.)

DEĞİŞKEN "PATH_VARIABLE dosya adı" (tırnak içinde) biçiminde olabilir, bu durumda
iki nokta üst üste ile ayrılmış dizinin ilk dizini varsa hedefler güncelliğini yitirmiş sayılır
dosya adının bulunduğu PATH_VARIABLE değeri son derlemeden farklı.
Bu, PATH_VARIABLE bir değişkende değiştiğinde hedeflerin yeniden oluşturulmasını önlemek için kullanılabilir.
alakasız yol

:sevk etmek komuta ...
Her kabuk eylemini (Perl eylemlerini veya Perl komutlarını değil) bir "sh -c '...'" içine alın
ve onu komutla önekleyin, ancak hedefin komuta bağlı olmadığını varsayın.
Bu, bir iş kuyruğa alma sistemine eylemler göndermek istiyorsanız kullanışlıdır, ancak sonuç şudur:
Kuyruklama parametrelerinden bağımsız olduğu varsayılır ve
sistem tamamen kullanılmaktadır.

:Dahil etmek dosya_or_pattern
Kural derleyiciye göre değişir:

%.o : %.c
: %.d dahil : imza C
gcc -MD -c ...

%.o : %.c
: %.u içerir : imza C # IBM farklı bir son ek kullanır
xlc -M-c ...

sub bağımlı { # Microsoft'un sohbetini kullanışlı bir biçime dönüştürün
s/\$/\$\$/g;
s/(Not: dosya dahil: *)?(.+?)\r?\n/$1 ? "'$2' " : "'".f_output()."': "/e;
}
%.o : %.c
: %.d dahil : imza C
cl -showInclude -c ... >$(stem).d
&sed &dependify -o +<$(stem).d

Bazı derleyiciler (Intel'in icc'si yukarıdaki gcc gibi veya IBM'in xlc'si) bağımlılık üretebilir
anında dosyalar. Yani derlerken makepp'in yapabileceği bir makefile yazarlar.
Dahil etmek. Makepp tarayıcısına göre avantajı, %100 olmasının garanti edilmesidir.
doğru, sadece yaklaşabileceğimiz yer.

Bu seçenek, bunu özel bir şekilde kullanır: Dosya yoksa, ör.
tipik olarak 1. derlemede normal tarama gerçekleşir. Ancak dosya mevcutsa, hayır
tarama gerçekleşir (bu nedenle yukarıda akıllı bir imza belirledik - tarama değil düşüyor
zaman damgası ve boyutun aptal varsayılanına geri dönün). Bunun yerine dosyayı içerir, daha önce
kuralı uyguluyor. Kuralı başarılı bir şekilde uyguladıktan sonra, ne olursa olsun unutur.
dosyanın güncelliğini yitirmiş olabileceği göz önüne alındığında, ilk kez okuyun. Bunun yerine okur
dosya değiştiyse, güncel yapı bilgilerine sahip olmak için tekrar.

UYARI: Bu, doğası gereği güvenilmezdir. Bağımlılık dosyası çok tarafından üretilir
bağımlı olduğu kural. Öte yandan, derleyici her şeyi bilir.
makepp'in genellikle görmezden geldiği dahili alt öğelerdir. Bu bir güvenilirlik
yalnızca bir derleyici yamasının yalnızca alt içerikleri düzelttiği durumda avantaj sağlar. NS
fiyat, makepp'in daha fazla dosyaya bakmakla sonuçlanmasıdır, bu da zaman alır.

Bir "#include" ifadesini kaldırdığınızda bir sorun var ve ilgili dosya:
Bağımlılık dosyasında, en son ne zaman olduğu, yine de bahsedilecektir.
gerekli. Böyle bir durumda, bağımlılığı kaldırmak için bağımlılık dosyasını düzenlemeniz gerekir.
ki bu artık yerine getirilemez.

Bu özellik, oradan bir dosya getirildiğinden derleme önbelleği ile kullanılamaz.
dosya hakkında her şeyi bilmeyi gerektirir. Ancak bir bağımlılık dosyası bunlara bağlıdır
makepp dosyaları okuyarak öğrenir. Böyle bir döngüsel bağımlılık normalde
güvenilir bir yapı sisteminde mümkündür. Bu bir istisna çünkü yeniden inşa ettikten sonra
ve bir bağımlılık dosyasını yeniden okumak, her şey tekrar doğru.

Depolarınızı oluşturursanız, makepp bağımlılık dosyasını şu adresten alır:
Bir tane içeren 1. depo. Bu, 1. dosyayı aldığı diğer dosyalardan farklıdır.
Beklenen imza ile. Bu, önbellek oluşturmadan daha iyidir, burada
imza, dosyayı bile bulamıyor.

:son şans
Açık uçlu bir kuralı etkinleştirin, örneğin

%.foo foo%.bar: :last_chance
&echo $@ -o $@
&cp $(çıktılar)

Bunun gibi bir kural, özünde sonsuz sayıda hedef üretebileceğinden,
bu kuralın bir hedefi, bir $(joker karakter) işlevi veya model kuralıyla eşleşmeyecektir.
başka bir şey, özellikle hedefe atıfta bulunarak kuralı zaten örneklemiştir.
Ayrıca, "--rm-stale" belirtilirse, bir önceki hedeften arta kalan bir hedef
makepp run, oluşturmanın tek yolu bir last_chance kuralıysa, bayat görünecektir
henüz hedef için örneklendirilmemiş, bu istenen bir davranış çünkü
derleme, hatalı bir şekilde bir joker karaktere dayandığında daha tutarlı bir şekilde başarısız olur.
önceki bir çalıştırmadaki hedefleri eşleştirin.

":last_chance" seçeneği, kullanıcının özel davranışına dikkat çekmeyi amaçlar.
eşleşen joker karakterlere ilişkin kural.

: ayrıştırıcı ayrıştırıcı
Bu, makepp'e dosyaları algılamak (dahil etmek) için komutu nasıl ayrıştıracağını söyler. Genellikle,
makepp, komutun kendisindeki kelimelere dayanarak bunun nasıl yapılacağını tahmin eder (bkz.
ayrıntılar için makepp_scanning). Ancak, makepp yanlış tahminde bulunursa,
ayrıştırıcıyı açıkça şöyle belirtin:

%.o: %.abc
: ayrıştırıcı c_derleme
burada eylem

Bu, makepp'in C/C++ için yaptığıyla aynı ayrıştırma ve taramayı gerçekleştirmesine neden olur.
eylemi bir C derlemesi olarak tanımasa bile komutları oluşturun.

Varsayılan ayrıştırıcı komuta bağlıdır. Bir ":parser" seçeneği belirtmezseniz,
daha sonra her komutun ilk kelimesi incelenir. Örneğin bir derleme veya bağlantı için
komutu, makepp "c_compilation" ayrıştırıcısını kullanır; veya komut şuna benziyorsa
GNU varyantı, "gcc_compilation". Ayrıştırıcı bulunamazsa "yok" ayrıştırıcısını kullanır. İçin
bununla ilgili daha fazla ayrıntı veya kendi ayrıştırıcınızı yazmak veya makepp'leri değiştirmek istiyorsanız
varsayılan ayrıştırıcılar, bkz. makepp_scanning.

Bunun, kuraldaki her komut için geçerli olduğunu ve istediğiniz gibi olmayabileceğini unutmayın:

%.o: %.c : ayrıştırıcı c-derleme
@echo '$(çıktı) oluşturma'
@komik_cc...

Bu aynı zamanda "yankı"yı bir derleyici olarak yorumlayacak ve "Bina Oluşturma" argümanını çıkaracaktır.
mymodule.o' örtük bir bağımlılık olarak. Bu şikayete yol açacaktır
böyle bir dosyanın nasıl oluşturulacağını bilmiyor. Bu durumda ile daha iyi olurdu
"register_parser". Orada nasıl bir açıklama bulursun ayrıştırıcı ya olarak verilebilir
sınıf adı veya işlev adı olarak.

:imza imza_yöntemi
hedef: bağımlılıklar
: imza md5
eylemler

Bu, makepp'e bağımlılıkların değişip değişmediğini belirlemek için hangi algoritmanın kullanılacağını söyler.
Daha fazla ayrıntı için makepp_signatures'a bakın. Dahil edilen imza yöntemleri
makepp dağılımı "düz", "md5", "C" veya "c_compilation_md5" şeklindedir ve
"paylaşılan_nesne". Bu, "-m" ile belirtilen herhangi bir imza yöntemini geçersiz kılar veya
"--signature-method" komut satırı seçenekleri veya "signature" deyimi ile.

Özel karakterler
Makepp, iki nokta üst üste veya boşluk gibi özel karakterler içeren dosya adlarını destekleyebilir.
Örneğin, "b:thing" dosyasından "a:thing" adında bir dosya oluşturmak istediğinizi varsayalım.
Kuralı şu şekilde yazamazsınız:

a:thing : b:thing # Bu bir sözdizimi hatasıdır
&cat $(girdi) -o $(çıktı)

çünkü makepp, hangi kolonların hedefleri bağımlılıklardan ayırdığını ve hangilerinin
dosya adlarının bir parçası. Bunun yerine, adı şu şekilde tırnak içine alın:

"a:şey": "b:şey"
&cat $(girdi) -o $(çıktı)

Şimdi kural açık.

Makepp'in alıntı sözdizimi kabuğunkine oldukça benzer. Örneğin, tek kullanabilirsiniz
çift ​​tırnak yerine tırnak içine alabilir veya ters eğik çizgi ile özel karakterlerden kaçabilirsiniz:

a\:şey : 'b:şey'
&cat $(girdi) -o $(çıktı)

Örneğin, dosya adınızın "'"!;\$" olduğunu varsayalım. Şimdi neden böyle bir dosya adı istiyorsunuz?
Bilmiyorum, ancak bunu makepp (ve kabuk) olarak belirtmenin birkaç yolu var:

\''"!;\$$'
"'\"!;\\$$"

Makepp'in ne zaman alıntı yaptığına ve kabuğun ne zaman yaptığına dikkat edin. Makepp bakar
sadece aşağıdaki durumlarda alıntı yapar:

· "ifeq" test ailesinde

· kural kolonundan önce ve sonra

· makepp yerleşik komutunda

· dosyalarla ilgili bir işlevde

Kabuktan farklı olarak makepp, tırnakları bir değişkene atarken genişletmez. Böylece
aşağıdaki kurallar aynıdır:

DOSYA = 'boşluklu isim'
x := $(print $(FILE)) # sadece alıntıların hala orada olup olmadığını kontrol etmek için
$(FILE): makepp tarafından ayıklanmış tek bir dosyanın etrafında # tırnak işareti
&echo merhaba -o$(FILE) # makepp tarafından ayıklanmış tek bir dosya etrafında tırnak işareti
echo orada >>$(FILE) # Shell tarafından ayıklanmış tek bir dosya etrafında tırnak işareti
'boşluklu ad':
&echo merhaba -o'boşluklarla isim'
echo orada >>'$(output)' # tırnak yukarıdan çıkarıldı, tekrar ekleyin

"$" ile başlayan değişkenlerin (Kabuk'tan farklı olarak) single içinde bile genişletildiğini unutmayın.
alıntılar. Dolar işaretleri, tırnak işaretleri veya ters eğik çizgilerle korunamaz. Bir harf elde etmek için
dolar işareti, çift dolar işareti kullanın, örn.

$(hepsi sahte):
@&echo Bu bir dolar işaretidir: $$
@abcd'deki val için; echo $$val; tamamlamak

Genel olarak, alıntı yaparak hemen hemen her özel karakterle başa çıkabilmelisiniz.
bir şekilde. Buna boşluklar, kontrol karakterleri vb. dahildir. Ancak unutmayın ki
mevcut, makepp'in yorum sıyırma işlemi biraz basit ve herhangi bir "#" karakteri
boşluktan önce gelenler, nasıl alıntı yapılırsa yapılsın yorum olarak yorumlanacaktır.

Bir hedef veya bağımlılık adı "$(output)" gibi otomatik bir değişkene konulduğunda,
tırnak işaretleri ve ters eğik çizgiler çıkarılır. Bu, şu anlama gelir:
eylemlerde dosya adı, muhtemelen tekrar alıntı yapmak zorunda kalacaksınız, şöyle:

"boşluklu bir dosya adı":
echo "Özel içerikler" > "$@"

Alıntıları $@ etrafına koymazsanız, kabuk komutu görecektir.

echo "Özel içerikler" > boşluklu bir dosya adı

adı verilen dosyaya "Boşluklu özel içerik dosya adı" dizesini yazan a.
Muhtemelen istediğin bu değil.

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