makepp_functions - Bulutta çevrimiçi

Program:

ADI

makepp_functions -- makepp içindeki işlevler

TANIM

A: mutlak_dosyaadı,
mutlak_dosyaadı_nolink,
abspat,
ek ön ek,
ek,
ve, B: temel ad, C: aramak, D: dir
dir_noslash, E: hata, F: dosyasubst,
filtre,
filtrelemek,
filtre_out_dirs,
dosyayı bul,
bul_ilk_yukarı,
bul_program,
bulucu,
bul_yukarı doğru,
ilk_uygun,
İlk kelime,
her biri için, I: Eğer,
Eğer doğruysa,
infer_bağlayıcı,
çıkarım_nesneleri,
bilgi, J: katılmak, M: Yapmak,
makemap
yapıcı,
harita,
"mktemp", N: değil, O: sadece_generated,
yalnızca_hedef olmayanlar,
only_phony_targets,
sadece_stale,
sadece_hedefler,
ya da,
Menşei, P: patsubst,
perl,
sahte,
önceden oluşturulmuş,
Yazdır, R: gerçek yol,
göreceli_dosyaadı,
göre, S: kabuk,
çeşit,
şerit,
alt alt,
eki, T: geçici, W: uyarı,
joker karakter,
kelime,
kelime listesi,
kelimeler, X: xargs

"$(ad)" biçimindeki herhangi bir ifade, burada "ad" bir değişkenin adı değildir veya
"$(name arg1 arg2 arg3)" bir işlev çağrısı olarak yorumlanır. İsim harfler içerebilir,
alt çizgiler veya kısa çizgiler; karışıklığı önlemek için kısa çizgi veya alt çizgi kullanabilirsiniz
değiştirilebilir, çünkü dahili olarak kısa çizgiler alt çizgilere dönüştürülür. Böyle değerlendirmek
bir ifade basitçe bir Perl alt yordamını çağırır. "name"den önce "&" varsa,
makepp işlemi içinde bu ismin yerleşik komutu veya betiği ve standardı döndürür
çıktı. Bu, PerlIO için Perl oluşturulmasını gerektirir. Ad bir işlevi adlandırmıyorsa
çağrı çağrısına dönüştürülür.

Değişkenlerde olduğu gibi "$(name ...)" veya "${name ...}" seçeneğiniz vardır. İsterseniz
aynı parantezi gömün, eşleştirilmesi gerekir, diğeri önemli değil: "$(isim
...(){..." veya "${name ...{}(...}". (Ancak map ve perl için ilk kapanış pareni biter)
ifade.) İkiye katlama, argümanların birkaç satıra yayılmasını sağlar. yeni satırlar
daha sonra belki "tanımla" dışında boşluk olarak ele alınır. Ayrıca "$[name ...]" sözdizimi de vardır.
veya grokking kurallarından önce makefile okunurken değerlendirilen $[[name ...]]
ve diğer yapılar.

Makepp, yararlı olabilecek bir dizi yerleşik işleve sahiptir. Hemen hemen hepsini destekler
GNU make'nin metinsel işlevleri (ayrıntılar için GNU make'nin belgelerine bakın) ve bazı
sahip olmak. İstediğinizi yapmak için Perl altyordamları tanımlayabilirsiniz. "Alt" ifadeye bakın
ve daha fazla ayrıntı için makepp'i genişletme bölümü.

Şartlı fonksiyonlar
ve durum1[,durum2[,durum3...]]
and işlevi bir "kısa devre" VE işlemi sağlar. Her argüman
sırayla genişletildi. Bir argüman boş bir dizgeye genişlerse, işleme durur ve
genişletmenin sonucu boş dizedir. Tüm bağımsız değişkenler olmayan bir değere genişlerse
boş dize, ardından genişletmenin sonucu, son argümanın genişletilmesidir.

if dize, sonuç-if-string-boş değil[, sonuç-if-string-boş]
Eğer doğruysa dize, sonuç-if-string-true[, sonuç-if-string-yanlış]
"ifeq" vb. ifadelere bir alternatif. Dize boş değilse (yani,
koşul doğrudur), ikinci argüman ("sonra" yan tümcesi) döndürülür (sonradan
değişken genişleme); dize boşsa, üçüncü argüman ("else" yan tümcesi)
iade.

Örneğin,

CFLAGS := $(eğer $(filtre gcc egcc, $(CC)), -g -Duvar, -g)

CC değişkeni "gcc" veya "egcc" ve "-g" ise CFLAGS'ı "-g -Wall" olarak tanımlar
aksi halde. (Varsayılan derleme kuralları bunu yapar.)

"iftrue", 0 dizesinin boş olarak değerlendirilmesi dışında "if" ile benzerdir.

or durum1[,durum2[,durum3...]]
veya işlevi bir "kısa devre" VEYA işlemi sağlar. Her argüman genişletilir,
sırayla. Bir argüman boş olmayan bir dizgeye genişlerse, işleme durur ve
genişletmenin sonucu bu dizedir. Tüm argümanlar genişletildikten sonra, tüm
bunlar false (boş), ardından genişletmenin sonucu boş dizedir.

fileto ve Dosya adı fonksiyonlar
mutlak_dosyaadı Dosyaları
absat Dosyaları
Göreceli dosya adlarını mutlak değerlere dönüştürür . or ... Örneğin,
"$(absolute_filename xyz.c)", "/usr/src/our_project/subdir/xyz.c" değerini döndürebilir.

mutlak_dosyaadı_nolink Dosyaları
gerçek yol Dosyaları
Mutlak_dosyaadı gibidir, ancak sembolik bağların çözülmesini sağlar.

baz adı dosya adları
Temel ad, dosya adının tamamıdır (dizinle birlikte), eksi metinden sonra ve
son dönem dahil. Örneğin, "$(basename myfile/version-1.0-module.c)"
"dosyam/versiyon-1.0-modülü"

dir dosya adları
Sondaki de dahil olmak üzere dosya adı listesindeki her dosyanın dizin bölümünü çıkarır.
yırtmaç. Dosya adında dizin yoksa "./" döndürür.

dir_noslash Dosya
Sondaki eğik çizgiyi döndürmemesi dışında "$(dir )" ile aynıdır.

dosyasubst Desen, vekil, sözler
Dosya adlarında bir kalıp değişimi gerçekleştirin. Bu, şunda patsubst'tan farklıdır:
dizinler için alternatif adlar verildiğinde (olduğu sürece) doğru şekilde çalışacaktır.
yüzde işaretinden önce gelirler). Örneğin,

$(filesubst ./src/%.c, %.o, $(joker karakter src/*.c))

filesubst ile çalışır ancak patsubst ile çalışmaz.

filtre_out_dirs dosya adları
Dizinlere başvurmayan tüm dosya adlarını döndürür.

dosyayı bul dosya adı, yol
Belirtilen yolda veya hiçbir şey yoksa PATH ortam değişkeninde bir dosya bulur
belirtildi. Bu, ikili dosyaları bulmak veya dosya eklemek için yararlı olabilir. Örneğin,

TCL_INCLUDE := -I$(dir_noslash $(findfile tcl.h, \
/usr/local/stow/tcl-8.4.5-nothread/include \
/usr/include/tcl8.4 /usr/include/tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

Bu dosyayı bulur tcl.h yukarıdaki dizinlerin tümünü arayarak. Mutlak
dosyanın yolu döndürülür. Ardından "$(dir_noslash )" bu dizini çıkarır ve
içerme yoluna konur.

bul_programı isim
PATH'de bulunabilecek listedeki ilk programı döndürün. Bu kullanışlı
kullanılabilecek birden fazla eşdeğer program olduğunda ve
bunlardan birini seçin. Örneğin, burada birkaç yaygın tanımın varsayılan tanımı verilmiştir.
makepp'in sağladığı değişkenler, makefile'nize bir tane koymazsanız:

CC = $(find_program gcc egcc pgcc c89 cc) # ve daha fazlası, makineye bağlı olarak
F77 = $(find_program f77 g77 fort77)
CXX = $(find_program g++ c++ pg++ cxx CC aCC)

Programlardan hiçbiri bulunamazsa, "$(find_program )", bulunamadı dizesini döndürür ve
bulunamadığını kaydeder. Bu genellikle işlevsel bir makefile ile sonuçlanmaz, ancak
daha iyi hata mesajları verme eğiliminde olacaktır. Örneğin, şöyle bir şey yaparsanız
bu:

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

ve makepp yukarıdaki listede bir C derleyicisi bulamazsa, bulunamadı-found'un yerini alacaktır.
Aksi takdirde, kabuk kaynak dosyayı çalıştırmayı dener ve ortaya çıkan hata
mesaj gerçekten garip olabilir.

yukarıya doğru bul Dosya
., .., .. dizininde verilen ada sahip bir dosyayı arar./ ..../../..Vb
dosya bulunana veya kök dizine ulaşılana veya dizin bulunana kadar
farklı bir dosya sisteminde. (Bu son gereklilik, aşağıdakilerle ilgili sorunları önlemek içindir:
automounters veya asılı ağ dosya sistemleri.) RootMakepp dosyası, bu da
daha yüksek aramayı engelleyen bir bariyer.

Örneğin, birçok alt dizine sahip bir projeniz varsa,
bu ortak parçayı tüm makefile'lere dahil edin (örneğin, "include" kullanarak
Beyan):

TOP_LEVEL_INCLUDE_DIR := $(find_upwards içerir)
# Aşağıdakileri içeren bir dizini arar:
# alt dizini içerir.

%.o : %.c
$(CC) $(CFLAGS) -I$(TOP_LEVEL_INCLUDE_DIR) -c $(giriş) -o $(çıktı)

"Find_upwards"ın çözmeye yardımcı olabileceği bir diğer sorun, en üst düzey dizini bulmaktır.
bir yapının. Genellikle aşağıdaki gibi bir değişken tanımlamak yararlıdır:

ÜST := ../../..

sadece üst düzey dizinde bulunan bazı önemli bilgileriniz varsa. Fakat
Bunu sürdürmek zordur, çünkü ".." sayısı farklı seviyeler için farklıdır
dizin ağacının Bunun yerine, bir dosyayı bulmak için "find_upwards" öğesini kullanabilirsiniz.
yalnızca üst düzey dizinde bulunduğu bilinmektedir. Diyelim ki, örneğin,
"LICENSE" dosyası yalnızca üst düzey dizinde bulunur. O zaman şunu yapabilirsin:

ÜST := $(dir_noslash $(find_upwards LİSANS))

"$(find_upwards LICENSE)", lisans dosyasının tam yolunu döndürür;
"$(dir_noslash ...)" dosya adını çıkarır ve yalnızca dizini döndürür.

("include" ifadesinin dosyaları otomatik olarak yukarıya doğru aradığına dikkat edin, bu nedenle
böyle bir şey yapmaya gerek yok:

$(find_upwards top_level_rules.mk) içerir

Bunun yerine, sadece yapabilirsiniz

top_level_rules.mk'yi dahil et

ve aynı şekilde işe yarayacaktır.)

Dosya bulunamazsa, "find_upwards", derlemeyi bir hata mesajıyla iptal eder.

Birden fazla dosya belirtirseniz, find_upwards ilkini arayacaktır, ardından
ikincisi, vb. Başka bir deyişle,

$(find_upwards dosya1 dosya2)

eşdeğerdir

$(find_upwards dosya1) $(find_upwards file2)

Dosyalardan herhangi birini aramak istiyorsanız, bunun yerine "find_first_upwards" öğesini kullanın.

find_first_upwards file1 file2 ...
Bu işlev, herhangi birinin ilk dosyasını döndürmesi dışında "find_upwards" gibi davranır.
bulduğu listedeki dosyalar. Özellikle, geçerli dizini kontrol eder.
listedeki dosyalardan herhangi biri ve var olan veya oluşturulabilecek ilk dosyayı döndürür.
Dosyalardan hiçbiri mevcut değilse veya bu dizinde oluşturulamıyorsa, kontrol eder. .., Daha sonra
../ .., vb., kök dizine veya bir dizine ulaşana kadar
farklı bir dosya sisteminde bulunur.

ilk_mevcut file1 file2 ...
Var olan veya oluşturulabilecek bir listedeki ilk dosyayı döndürün. Bunun için yararlı olabilir
makefile dosyalarınızı birkaç farklı makinede veya ağda çalışacak şekilde uyarlamak;
önemli dosyalar farklı yerlerde bulunabilir. Örneğin, işte bir satır
makefile dosyalarımdan biri:

TCL_LIB = $(ilk_kullanılabilir \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

Bu satır, yukarıdaki yerlerin tümünde Tcl kitaplığını kontrol edecek ve şurada duracaktır:
bulduğu ilk kişi. link komutu daha sonra $(TCL_LIB) içerir, böylece
uygun Tcl kütüphanesi.

çıkarım_bağlayıcı file1 file2 ...
Nesne dosyalarının bir listesi verildiğinde, henüz yapılmadıysa, önce bunları oluşturun. sonra bul
Fortran, C++ veya C kaynağına bağlı olup olmadıkları ve karşılık gelen
derleyici ("ld" den daha iyi bağlantı kurmayı bilir).

çıkarım_nesneleri file1 file2 ..., model
$(infer_objects nesne1.o nesne2.o, *.o)

Başlık dosyası adlarıyla ilgili standart kuralları kullanırsanız, makepp şunları yapabilir:
Hangi ".o" veya ".lo" dosyalarının programınıza bağlanması gerektiğini tahmin etmek. bunu kullanıyorum
birçok farklı şekilde kullanılan modülleri içeren bir kitaplık dizininden dosyaları seçin
programlar. Bir kitaplık ".a" dosyası oluşturmak ve bağlayıcının aşağıdakileri seçmesini sağlamak yerine
ilgili modüller, makepp sizin için ilgili modülleri seçebilir. Bu şekilde, sadece
ilgili modüller derlenir.

Makepp'in nesne bağımlılıklarını çıkarmaya yönelik algoritması,
"xyz.h" başlık dosyasında tanımlanan tüm sınıfların veya işlevlerin uygulanması
"xyz.o" (veya "xyz.lo") adlı bir nesne dosyasında derlenir. Yani makepp'in algoritması
çıkarım yapan nesne bağımlılıkları, olması gerektiğini bildiğimiz bir veya birkaç nesneyle başlar.
programa bağlı. Hangi dosyaların "#include" ile dahil edildiğine bakar.
bu kaynaklar ve dahil edilenlerin her biri için karşılık gelen nesne dosyalarını bulmaya çalışır.
dosyaları.

Bir programın bağımlılık listesinde "$(infer_objects )" belirtilmelidir, örneğin
bu:

programım: $(infer_objects ana.o other_object.o, \
**/*.o /other/library/dirs/**/*.o)
$(CXX) $(girdiler) -o $(çıktı) $(LIBS)

"$(infer_objects)" işlevi iki bağımsız değişken alır (gösterildiği gibi virgülle ayrılmış).
Birincisi, gerekli olduğu bilinen bir veya birkaç nesne dosyasıdır (joker karakterler
burada izin verilir). İkincisi, olası nesnelerin bir listesidir (normalde bir
joker karakter burada) gerekirse bağlanabilecektir. Bundan dönüş değeri
function, ilk argümandaki tüm nesneleri içeren bir listedir ve
sonra bunlardan sonra, ikinci argümanda yer alan tüm ek nesneler
ilk argümandaki nesneler tarafından gerekli olan.

Örneğin, "main.o"nun "my_class.h"yi içeren "main.cpp"den geldiğini varsayalım.
"$(infer_objects)", "my_class.o" adlı dosyaları arar. Eğer tam olarak böyle biri
dosya bulunursa listeye eklenir. ("my_class.o" adlı iki nesne dosyası bulunursa
farklı dizinlerde bir uyarı mesajı yazdırılır.) "infer_objects" ayrıca
ne içerdiğini ve hangi ek nesne dosyalarının olduğunu görmek için "my_class.cpp" dosyasını inceler
ima etti.

mktemp
mktemp önek
mktemp önekXXX
mktemp /
Şu anda mevcut olmayan, öngörülemeyen bir geçici dosya adı döndürür. İsimsiz
aynı dosyaya işaret etmek, farklı göreli yollarla bile iki kez döndürülür,
bir makepp çalıştırması içinde (muhtemelen geleneksel özyinelemeli make hariç veya Perl
bir kural eylemi içinde çalışan kod "f_mktemp" olarak adlandırılır). makepp sonunda hepsini çalıştırın
bu işlev tarafından döndürülen dosyalar varsa silinir (yine bunlar dışında
bir kural içinde çalışan Perl kodunda bu işlev tarafından döndürülür).

Argümanın sonundaki herhangi bir sayıda büyük harf "X", o kadar çok harfle değiştirilir:
rastgele harfler ve rakamlar. Ne kadar çok olursa, çarpışma olasılığı o kadar az olur
diğer işlemlerle, yani " gibi bir önek verirseniz/tmp/abc."yeterli olmalısın
"X"ler. Birden fazla X varsa, ilk karakter işlem kimliğinden gelir. Eğer
hiçbiri yok, sanki on tane varmış gibi, bu da yeterli (8.4e17)
olasılıklar veya Windows'ta 3.7e15). Argüman yoksa, önek varsayılan olarak
"tmp." geçerli dizinde.

Kural hedefleri ve bağımlılıklar gibi bir ad vermek istemediğinizi unutmayın. bu
sonuç doğru olurdu, ancak makepp'i her çalıştırdığınızda yeniden oluşturulur.

Ayrıca, her zaman farklı olduğu için, bunu bir kural eyleminde yalnızca
":build_check görmezden_eylem":

TMPFILE ;= $(mktemp) # 1 çağrı; "=" 3 çağrı anlamına gelir: 3 dosya
A-sayısı B-sayısı: :build_check görmezden_eylem
Üretim-As-ve-Bs >$(TMPFILE)
&grep -c /A/ $(TMPFILE) -o A-sayısı
&grep -c /B/ $(TMPFILE) -o B-sayısı

Veya dışa aktarmalı ve Shell'in değerlendirmesine izin vermelisiniz:

TMPFILE dışa aktar ;= $(mktemp)
A-sayısı B-sayısı:
Üret-As-ve-Bs >$$TMPFILE # makepp, var değerini görmüyor
fgrep -c A $$TMPFILE >A-sayısı
fgrep -c B $$TMPFILE >B-sayısı

Son form, önceki dönüş değerini tekrarlar, böylece onu bir kalıp kuralında kullanabilirsiniz:

%.x: %.y
&grep foo $(girdi) -o $(mktemp)
&sed bar $(mktemp /) -o $(output) # &grep çıktısı üzerinde işlem yap

notdir dosya adları
Dosya adlarının dizin olmayan bölümünü, yani sondan sonraki her şeyi döndürür.
varsa eğik çizgi, yoksa dosya adının tamamı.

only_geneated dosya adları
Yalnızca, o zamandan beri değil, makepp tarafından oluşturulan listedeki dosya adlarını döndürür.
derleme bilgi dosyasına göre değiştirildi.

Bu işlev temiz hedef kurallarında kullanışlıdır (tabii ki "makeppclean"
tercih edilen varyant):

$(sahte temizlik):
&rm -f $(only_generated **/*)

yalnızca_hedef olmayanlar dosya adları
Yalnızca listedeki herhangi bir kuralın hedefi olmayan dosya adlarını döndürür (ya
açık veya kalıp kuralları). Bir joker karakter belirtebilirsiniz ("$(wildcard )" bölümüne bakın)
makepp'in joker karakterleri hakkında daha fazla ayrıntı için işlev). Bu, bir oluşturmak için kullanılabilir
dağıtım hedefi, örneğin:

.PHONY: dağıtım

dağıtım:
&mkdir our_product-$(VERSION)
&cp $(filtre çıkışı %~, $(only_nontargets *)) our_product-$(VERSION)
tar cf - our_product-$(VERSION) | gzip -9c > our_product-$(VERSION).tar.gz

Bu durumda, "$(only_nontargets *)" geçerli dizindeki her dosyayı döndürür
bu bir kuralın hedefi değildir. "$(filter_out %~, ...)" düzenleyiciyi kaldırır
yedeklemeler.

"only_targets" (yukarıya bakın) benzer şekilde, "only_nontargets" yalnızca şu hedefleri bilir:
zaten tanımlanmış. Bu, yalnızca değişkenleri tanımlamak için kullanırsanız bir sorundur.
":=" ataması ile; bağımlılık listesinde veya bir gövdesinde kullanırsanız
kural, diğer tüm kurallar zaten görülmüş olacaktır.

sadece_stale dosya adları
Yalnızca, o zamandan beri değil, makepp tarafından oluşturulan listedeki dosya adlarını döndürür.
derleme bilgisi dosyasına göre değiştirildi, ancak artık herhangi bir kuralın hedefi değil.

Bu işlev, bu tür dosyalara bağımlılık olmamasını sağlamak için kullanışlıdır.
tüm hedeflerin temiz bir yapısını zorlamadan:

$(sahte floş):
&rm -f $(only_stale **/*)

Aslında, oluşturmak için makepp çağıran bir komut dosyası yazmak yerine muhtemelen daha iyidir.
eski dosyaların listesini ve ardından bu komut dosyasının listelenen tüm dosyaları kaldırmasını sağlayın.
şu anda kaynak kontrolü altında değil, oluşturulan bir dosyanın kaynak olması durumunda
dosya. Makepp'in yerleşik böyle bir işlevi yoktur çünkü makepp (ve muhtemelen
kalmalı) kaynak kontrolü konusunda agnostik.

sadece_hedefler dosya adları
Yalnızca listedeki bazı kuralların gerçekten hedefi olan dosya adlarını döndürür
(açık veya kalıp kuralları). Joker karakterler belirtebilirsiniz (makepp'ler dahil
özel joker karakter, "**") dosya adlarında. (Daha fazlası için "$(joker karakter )" işlevine bakın
detaylar. Bu, temiz bir hedef için kullanılabilir, örneğin:

.PHONY: temiz

temiz:
&rm -f $(only_targets *)

Şimdi "makepp clean" yazarsanız, nasıl oluşturulacağını bildiği her şeyi silecektir. Fakat
temiz bir hedef oluşturmayın, bunun yerine "makeppclean" kullanın!

Yararlı olabileceği başka bir yer, bayat eklemekten kaçınmaktır. .o içindeki dosyalar
yapı. Örneğin, şöyle bir kitaplık oluşturursanız:

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

ve sonra bazı kaynak dosyaları silersiniz ancak karşılık gelenleri silmeyi unutursunuz. .o dosyaları,
the .o dosyalar hala etrafta olacak. Bu, yine de dahil edilecekleri anlamına gelir
kütüphane, artık yararlı olmamalarına rağmen. modifiye ederseniz
böyle kural:

mylib.a: $(only_targets *.o)
&rm -f $(çıktı)
$(AR) cr $(çıktı) $(girdiler)

o zaman bu sorun oluşmayacaktır.

Bunun yalnızca hedef olduğu bilinen dosyalara atıfta bulunduğunu unutmayın. at the zaman sen
çağırmak "sadece-hedefler". Bir programın bağımlılıklarında veya eylemlerinde "only_targets" görünüyorsa,
kuralı, o zaman bağımlılıklar ve eylemler olmadığı için tüm olası hedefler bilinecektir.
kural uygulanana kadar değerlendirilir. Ancak değerlendirirseniz değerlendirmeye çalışın.
makefile'de daha önce şöyle bir ":=" değişkeni ile:

TÜM_TARGETLAR := $(only_targets *)

hedef1: bağımlılık1
eylemler

hedef2: bağımlılık2
eylemler

o zaman "only_targets" sonraki kuralları bilmeyecek.

Benzer şekilde, "only_targets", makefile'lerde üretilen hedefler hakkında bilgi sahibi değildir.
özyinelemeli make ile yüklenir. (Ama yine de özyinelemeli make kullanmamalısınız;
"load_makefile" ifadesini kullanın veya bunun yerine örtük makefile yüklemesini kullanın.)

göreceli_dosyaadı file1 file2 dosya3[, yırtmaç]
Geçerli dizine göre bu dosyaların adını döndürür (
makefile var). Bu aynı zamanda gereksiz "./" ve diğer gereksiz dosyaları temizlemek için de kullanılabilir.
yol:

YÖN := .
ALTDIR := ..
FNAME := $(DIR)/../otherdir/$(SUBDIR)/files
X := $(relative_filename $(FNAME))

If yırtmaç true (genellikle 1) döndürülen dosya adlarının eğik çizgi içermesi garanti edilir
gerekirse "./" öğesinin başına ekleyerek, böylece yürütülebilir bir ad olarak kullanabilirsiniz.
dizin konumunu geçersiz kılan komut arama yolu hakkında endişelenmek.

Yol kök dizinden geçiyorsa, ana dizininizin ebeveyni veya
yapı sisteminizin "$(ROOT)" veya Windows'ta bir sürücünün kök
çevre, bu da olur /cygdrive/c or /c), mutlak bir yol olacaktır
yerine döndü.

göre file1 file2 dosya3[, dizin]
Belirtilen dizine göre bu dosyaların adını döndürür. Bu
herhangi bir nedenle bir komuttan bir komut yürütmeniz gerektiğinde genellikle kullanışlıdır.
farklı dizin (varsayılan geçerli dizin):

kaynak_backup.tar:
cd .. && tar cf $(relative_to $(output), ..) $(relative_to ., ..)

sonek isimler...
Adlardaki her dosya adının son ekini ayıklar. Dosya adı bir nokta içeriyorsa,
son ek, son nokta ile başlayan her şeydir. Aksi takdirde, son ek
boş dize. Bu genellikle, adlar olmadığında sonucun boş olacağı anlamına gelir,
ve adlar birden çok dosya adı içeriyorsa, sonuç daha az dosya adı içerebilir.

Örneğin,

$(src/foo.c src-1.0/bar.c hack soneki)

".c .c" sonucunu üretir.

geçici sözler
Makepp'e, belirtilen hedeflerin oluşturan kural tarafından kaldırılabileceğini bildirin.
onlara. "Sahte"ye benzer, ancak makepp bu ada sahip gerçek bir dosyanın olmasını bekler.
kuraldan etkilenebilir. Bir kural, yalnızca geçiciyse yürütülmez
hedefler güncel değil.

joker model
Var olan veya verilen desenle eşleşen tüm dosyaların sıralanmış adlarını döndürür.
henüz var olmayan ancak makepp'in bildiği kurallara göre oluşturulabilen dosyalar
ifadeyi değerlendirdiği noktada. Bu son noktada farklı
daha sonra bulunan kurallar tarafından oluşturulan dosyalar için bile geçerli olan kural girişi joker karakterlerinden.

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
zsh'den çalındı.) Örneğin, "**/*.c", tüm .c tüm kaynaktaki dosyalar
ağaç. "objects/**/*.o" tüm öğelerle eşleşir .o herhangi bir yerde bulunan dosyalar
Alt dizin nesneler veya alt dizinlerinden herhangi biri veya alt dizinlerinden herhangi biri. bu
"**" joker karakteri, dizinlere herhangi bir düzeydeki yumuşak bağlantıları takip etmeyecek ve
var olan ancak okunamayan dizinlere girmeye çalışın. Ayrıca dosyalar ve
var olan ancak okunamayan dizinler "$(wildcard )" tarafından döndürülmez.

dizi fonksiyonlar
önek ekle önek, sözler
Sözcüklerin her birinin başına önek dizesini ekler. Bu çoğunlukla GNU yapımı içindir
uyumluluk; rc tarzı genişletme kullanılarak bu daha okunaklı bir şekilde yapılabilir
bunun gibi:

MODÜLLER := abcd
X_OLD_STYLE := $(addprefix $(OBJDIR)/, $(addsffix .o, $(MODULES)))
X_NEW_STYLE := $(OBJDIR)/$(MODULES).o # Okuması daha kolay değil mi?

ek eki, sözler
Sözcüklerin her birine son ek dizesini ekler. Bu çoğunlukla GNU yapımı içindir
uyumluluk; rc tarzı genişletme kullanılarak bu daha okunaklı bir şekilde yapılabilir
bunun gibi:

X_OLD_STYLE := $(ekleme .o, $(MODÜLLER))
X_NEW_STYLE := $(MODÜLLER).o

çağrı değişken[, sözler]...
"çağrı" işlevi, dikkate alınması için kullanılabilmesi açısından benzersizdir. değişken bir şekilde
parametreli fonksiyon. için karmaşık bir ifade atayabilirsiniz. değişken ve kullan
"çağrı", içeriğini şu şekilde parametrelenen farklı değerlere genişletmek için sözler daha sonra. İçinde
diğer marka sistemleri, esas olarak yoluyla genişletilmek amacıyla kullanılan bir değişkendir.
"çağrı" denir makro.

Makronun genişletilmesi sırasında, geçici değişkenler $1, $2, "..." bakın
çağrılması sırasında "çağrı" için verilen argümanlar. Değişken $0 genişletilecek
makronun adı (yani değişken) bu "çağrı" şu anda genişliyor.

Bir makronun kaç argümanla "çağrılabileceği" veya
bir makronun bekleyebileceği parametreler. Makro olarak "çağrı" için daha fazla argüman iletirseniz
Gerektiğinde, tüm aşan argümanlar atılacaktır. a'dan daha az argüman iletirseniz
makro bekler, tüm aşan parametreler boş dizeye çöker.

Önce basit bir örnek:

dinlenme = $(kelime listesi 2, $(kelimeler $(1)),$(1))
liste = ABCDE
butfirst := $(dinlenmeyi ara,$(liste))

Burada "$(butfirst)" değişkeni "BCDE" listesini içerecektir.

Ve şimdi neyin mümkün olduğunu göstermek için daha karmaşık bir örnek için:

dinlenme = $(kelime listesi 2,$(kelimeler $(1)),${1})
haritam = $(eğer $2,$($1'i arayın,$(ilk kelime $2)) $($0,$1'i arayın$(dinlenmeyi arayın,$2)))
küçük harf = ${makeperl lc("$1")}

UCWORDS = TÜM BU SÖZCÜKLER BÜYÜK HARF
DCWORDS := $(haritamı ara,küçük harf,$(UCWORDS))

Şimdi "$(DCWORDS)", "bütün bu kelimeler büyük harf" içeriyor. Bu arada: hayır yapar
fark, argümanlara üzerinden erişip erişemeyeceğimiz $1, "${1}" or "$(1)" bir makro içinde.

Değişkeni doğrudan bir işlevmiş gibi kullanabilirsiniz, yoksa
bu ismin işlevi. Bu, dahili olarak "çağrıya" dönüştürülür, bu nedenle bunlar
eşdeğer:

tartışma = $0, $1 $2'a dönüştü.
direct = $(tartışma ve argüman)
çağrılan = $(çağrı tartışması,an,argüman)

"$[call]" öğesinin makronun "$[]" öğesini de genişletip genişletmemesi tartışmalı görünebilir.
ifadeler veya bir işlevin nasıl olursa olsun her zaman aynı şeyi yapması gerekip gerekmediği
denir. İkincisi seçildi, çünkü normal make sözdizimi ile
"$[1], $[2]..." değişkenini bir değişkene sokmak imkansız (hiçbir şeyle yer değiştirmezlerdi,
atama gerçekleşmeden önce.) Bu nedenle, bir makro tanımlamak için bir makronuz varsa,
kural, kural ayrıştırıldığında "$(output)" gibi ifadelerin görünmesini istiyorsunuz, bu nedenle
onları "çağrıdan" korumalısınız:

myrule'yi tanımla
2 dolar: 1 dolar
komutum $$(girdi) -o $$(çıktı)
Endef
$[benim kuralım benim girdim, benim çıktım]

filtre desenler, sözler
Listedeki kalıplarla eşleşen tüm kelimeleri döndürür. Desenler basitçe başka olabilir
kelimeler veya dosya adı joker karakterleri (yani, "*", "?" ve "[az]" tanınır) veya bunlar
"%" karakterine sahip olmak, bu noktadaki herhangi bir dizeyle eşleşmek anlamına gelir ("*" ile aynı).

filtrelemek desenler, sözler
Listedeki kalıplarla eşleşmeyen tüm kelimeleri döndürür. Desenler basitçe olabilir
diğer kelimeler veya dosya adı joker karakterleri (yani, "*", "?" ve "[az]" tanınır) veya
"%" karakterine sahip olabilirler, bu da o noktada herhangi bir dizeyle eşleşmek anlamına gelir (aynı
"*").

Örneğin:

libproduction.a: $(filter_out testi_*, $(joker karakter *.o))

hepsini koyacak .o ile başlayanlar hariç, var olan veya oluşturulabilen dosyalar test_,
içine libprodüksiyon.a.

bulucu bulmak, in
Dönüş bulmak, eğer bir alt diziyse in.

İlk kelime sözler
İlk kelimeyi döndür.

harita kelimeler, perl kodu
harita yapmak kelimeler, perl kodu
Perl'in haritasına benzer şekilde, geçerlidir perl kodu sırayla her kelimeye döner ve
Sonuçlar. İlk değişken düz Perl kodudur, ikinci değişken ise ilk geçer
Perlcode, Make tarzı değişken genişletme yoluyla. Sözcükler her ikisinde de genişletilmiştir.
vakalar.

Sözcükler $_ içindedir ve $_ tanımını bozmadığınız sürece döndürülür. Bunun için tasarlanmıştır
"patsubst" tarafından kolayca işlenmeyen değişiklikler. Yalnızca ilk virgül ayırıcıdır,
diğerleri bir parçası olarak kabul edilir perl kodu.

# Kelimeleri değiştir. Perl kodunda parenlere izin vermek için çift parens veya ${} kullanın:
X = $((harita $(DEĞERLER), s/(.+)-(.+)/$2-$1/))
# make ifadeleri kullanabilirsiniz, ancak daha sonra Perl $ için $$ kullanmanız gerekir:
Y = $(makemap $(DEĞERLER), tr/$(ESKİ CHARS)/$(YENİ CHARS)/ veya $$_ = 'başarısız')
# Adayları eleyebilirsiniz:
Y = $(harita $(DEĞERLER), undef $_ if /no_good/)

kaydol kelimeler1, kelimeler2
İlk sözcükleri ve ikinci sözcükleri ikili olarak birleştirin.

patsubst Desen, vekil, sözler
Kelime listesindeki her kelime için bir ikame gerçekleştirir. Bir "%" karakteri herhangi biriyle eşleşir
sicim. Bu en iyi bir örnekle gösterilmektedir:

OBJS = $(patsubst %.c, object_dir/%.o, $(C_SOURCES))

C_SOURCES içindeki her dosyayı alır ve object_dir içindeki bir nesne dosyasının adını döndürür.
Bazen bir ikame referansı kullanmak daha özlüdür, örneğin, yukarıdakiler
olarak yazılmıştır

NESNELER = $(C_SOURCES:%.c=object_dir/%.o)

tür word1 word2 word3 ...
Sözcükleri sözcük sırasına göre sıralar ve yinelenenleri kaldırır.

şerit dizi
Dizenin başındaki ve sonundaki boşlukları kaldırır ve her bir dahili
tek boşluklu bir veya daha fazla boşluk karakteri dizisi. Böylece, "$(şerit ab
c )", "abc" ile sonuçlanır.

subst metinden
Metin metninde metinsel bir değişiklik gerçekleştirir: from öğesinin her tekrarı değiştirilir
tarafından. Sonuç, işlev çağrısı için değiştirilir. Örneğin,

$(alt ee,EE,sokakta ayaklar)

"fEEt on the street" dizesini değiştirir.

sözcük n,metin
Döndürür ninci kelime metin. meşru değerleri n başlangıçta 1'den başla
veya sonunda -1'den geriye doğru. Eğer n içindeki kelimelerin sayısından daha büyük metin,
değer boş.

Sözcük listesi dizin listesi, sözler
Sözcük listesi ilk indeks, son dizin, sözler
İlk formda bir endeks listesi sağlarsınız (başlangıçta 1'den sayarak veya
sonunda -1'den geriye doğru) istediğiniz kelimeleri seçin. İkinci formda sen
döndürülmesini istediğiniz kelime aralığını belirtin.

sözler metin
içindeki kelime sayısını döndürür metin.

Diğer fonksiyonlar
her biri için var,liste,metin
İlk iki argüman, var ve liste, başka bir şey yapılmadan önce genişletilir; Not
son argüman, metin, aynı anda genişletilmez. Daha sonra her bir kelime için
listenin genişletilmiş değeri, var'ın genişletilmiş değeriyle adlandırılan değişken
bu kelime ve metin genişletilir. Muhtemelen metin, bu değişkene referanslar içeriyor,
bu yüzden genişlemesi her seferinde farklı olacaktır.

Bu basit örnek değişkeni ayarlar Dosyaları içindeki tüm dosyaların listesine
listedeki dizinler dirs:

dizinler := abcd
dosyalar := $(foreach dir,$(dirs),$(joker karakter $(dir)/*))

Buradaki metin "$(joker karakter $(dir)/*)" şeklindedir. İlk tekrar, dir için "a" değerini bulur,
bu nedenle "$(wildcard a/*)" ile aynı sonucu verir; ikinci tekrar üretir
"$(joker karakter b/*)" sonucu; ve üçüncüsü, "$(joker karakter c/*)".

Bu örnek, aşağıdaki örnekle aynı sonuca ("dirs" ayarı dışında) sahiptir:

dosyalar := $(joker karakter a/* b/* c/* d/*)

Metin karmaşık olduğunda, ona bir ad vererek okunabilirliği artırabilirsiniz.
ek değişken:

find_files = $(joker karakter $(dir)/*)
dizinler := abcd
dosyalar := $(foreach dir,$(dirs),$(find_files))

Burada find_files değişkenini bu şekilde kullanıyoruz. Bir tanımlamak için düz "=" kullanırız
özyinelemeli olarak genişleyen değişken, böylece değeri gerçek bir işlev çağrısı içerir
foreach kontrolü altında yeniden genişletilebilir; basitçe genişletilmiş bir değişken yapmaz,
joker karakter, find_files tanımlanırken yalnızca bir kez çağrılacağından.

Not: Bunu "$(foreach)" özel değişkeniyle karıştırmayın.

bilgi metin
uyarı metin
hata metin
Hiçbir şeyi döndüren çıktı metni. Birincisi STDOUT'a, ikincisi STDERR'e gider,
üçüncüsü ayrıca işlemeyi durdurur.

önceden oluşturulmuş hedefler
yapmak hedefler
Bağımsız değişkenini kelimesi kelimesine döndürür, ancak önce listelenen tüm dosyaları oluşturur. Bu kullanışlı
bir make ifadesi değerlendirilirken belirli bir dosyaya ihtiyaç duyulduğunda. Bu genellikle olur
ilgili dosya kümesinin bir kabuk tarafından hesaplandığı bir yapınız olduğunda
komutlar. Örneğin,

dosya_listesi :
# programa yerleştirilecek dosyaların listesini hesaplamak için kabuk komutları

my_program : $(&cat $(prebuild file_list))

Listeye birden fazla kuralda ihtiyacınız varsa, bir kural kullanmak daha verimli olacaktır.
en fazla bir kez değişkeni genişlet:

file_list ;= $(&cat $(prebuild file_list))

my_program1 : ao $(file_list)

my_program2 : bo $(file_list)

Bunun yerine yalnızca "$(&cat file_list)" belirtirseniz, makepp zorlamaz
file_list'in kabuk komutunu çalıştırmadan önce güncel olması gerekir. "$(prebuild )" kullanma
bu sorunu çözmenin en iyi yoludur. gibi başka şeyler denemek isteyebilirsiniz.
bu:

my_program : file_list $(&cat file_list)

ancak bu işe yaramaz çünkü "$(&cat file_list)" makepp denemeden önce değerlendirilir.
"file_list" oluşturun.

only_phony_targets isimleri
Yalnızca listedeki bazı kuralların sahte hedefleri olan adları döndürür (ya
açık veya kalıp kuralları). Joker karakterler belirtebilirsiniz (makepp'in özel
joker karakter, "**") dosya adlarında. (Daha fazla ayrıntı için "$(joker karakter )" işlevine bakın.
Bu, hedefleri gruplamak için kullanılabilir, örneğin:

$(sahte testler): $(only_phony_targets */**/testler)

köken değişken
Bir değişkenin adı verildiğinde, değerinin nereden geldiğini size söyler.

perl perl kodu
yapıcı perl kodu
Bir bloktaki perl kodunu değerlendirir ve sonucu döndürür. İlk varyant düz Perl'dir.
kodu, ikinci değişken ise ilk önce Perl kodunu Make-style değişkeninden geçirir.
genişleme.

Tüm işlevlerde olduğu gibi, kullanılan işlev sınırlayıcısının aşağıdakiler içinde görünmeyebileceğini unutmayın.
perlcode tek veya çift tırnaklı dizelerin dışında. Ama olduğu gibi ikiye katlayabilirsiniz
son örnek:

VAR = 1
VAR1 = ${Perl ($VAR + 1) * 3}
VAR2 = $(perl do { $VAR *= 3; $VAR ise $VAR + 1 } döndür)
VAR3 = $(makeperl $(VAR1) * 3 + $$VAR) # bir Make var ve bir Perl var
VAR = $((perl if( ... ) { ... }))

sahte sözler
Sözcük listesinin aslında sahte hedefler olduğunu belirtir ve aşağıdakilerin listesini döndürür.
hedefler. Bu şekilde kullanılmak üzere tasarlanmıştır:

$(hepsi sahte): my_program

$(sahte temizlik):
&rm -f *.o programım

Ayrıca, herhangi bir yerde bunun gibi bir çizgiyle bir veya daha fazla hedefi sahte olarak ilan edebilirsiniz.
makefile'niz:

.PHONY: hepsi temiz

baskı metin
Metni çıkarır ve döndürür. Bu, çoğunlukla hata ayıklama için kullanışlıdır.
değişken ikamesinin neden böyle bir sonuca sahip olduğunu anlayın. Örneğin,

XYZ := $(yazdır $(patsubst %.c, %o, $(SOURCE_FILES)))

"patsubst" çağrısının sonucunu yazdıracaktır.

XYZ := $(patsubst %.c, %o, $(yazdır $(SOURCE_FILES)))

"patsubst" çağrısının son argümanını yazdıracaktır.

kabuk kabuk komutu
Verilen kabuk komutunun çıktısını, yeni satırların boşluklarla değiştirildiği şekilde döndürür.

Tüm işlevlerde olduğu gibi, kullanılan işlev sınırlayıcısının aşağıdakiler içinde görünmeyebileceğini unutmayın.
tek veya çift tırnaklı dizelerin dışındaki kabuk komutu. Ama ikiye katlayabilirsin
ikinci örnekte olduğu gibi:

tarih = $(kabuk tarihi) # daha iyi: $(perl skaler yerel zaman)
VAR = ${{shell f() { echo merhaba; }; F}}

xargs komut,argümanlar[,sonek[,uzunluk]]
Her biri belirtilenle başlayan yeni satırla ayrılmış bir komut listesi döndürür
komut verin ve listenin mümkün olduğunca çok öğesiyle, üzerinden geçmeden sonlandırın.
uzunluk (varsayılan 1000) karakter.

Bunun amacı, sisteminizdeki komut uzunluğu sınırını aşmamaktır.
Örneğin, çok sayıda oluşturulmuş dosya varsa, muhtemelen
temiz hedef ("makeppclean" daha verimli olduğu için sahip olmamanız gereken)
şöyle bir şeye bak:

$(sahte temizlik):
$(xargs $(RM), $(only_targets **/*))

Bunun ayrıca, listede herhangi bir komutun üretilmemesi gibi bir yan etkisi de vardır.
boş olur. Ancak bu durumda &rm yerleşikini kullanmak daha iyi olur,
çünkü yerleşik komutların argümanları yalnızca Perl'in belleği ile sınırlıdır:

$(sahte temizlik):
&rm -f $(only_targets **/*)

Üçüncü bir argüman belirtilirse, o zaman her bir komutu sonradan düzeltmek için kullanılır. Bu
yeniden yönlendiricileri belirtmek için kullanışlıdır, örneğin (yine burada &echo yardımcı olacaktır):

belirgin:
&rm -f $@
&dokunun $@
$(xargs echo, $(only_nontargets **/*), >> $@)

Bu belgelerin bazıları GNU make belgelerine dayanmaktadır.

Lütfen, makefile başlatma sırasında bir işlev çağrılırsa, örn.
dışa aktarma değişkenlerinin genişletilmesi, hata veya uyarı mesajları, satır numarası 0'ı bildirir.

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