makepp_variables - Dalam Talian di Awan

JADUAL:

NAMA

makepp_variables -- Cara menggunakan pembolehubah dalam makepp

DESCRIPTION

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAGS,
AS, C: DC,
CFLAGS,
"bergantung_berubah",
berubah_input,
CURDIR,
CXX,
CXXFLAGS, D: "kebergantungan",
"pergantungan", F: F77,
FC,
"untuk setiap", I: input,
input, L: LD,
LEX,
LIBTOOL, M: BUAT,
MAKECMDGOALS,
MAKEFLAGS,
MAKEINFO,
MAKEPP_DEBUG,
MAKEPFLAGS,
_MAKEPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "pengeluaran",
"keluaran", P: PERL,
OKU, R: RM,
AKAR, S: SHELL,
"sorted_dependencies",
sorted_inputs,
"batang", T: sasaran,
sasaran, V: VPATH, Y: YACC

Makefiles biasanya menggunakan pembolehubah di banyak tempat. Satu sebab penting untuk menggunakan
pembolehubah adalah untuk memastikan bahawa maklumat terkandung dalam satu tempat sahaja dalam fail make, jadi
bahawa jika ia berubah, tidak ada bahaya kedua-dua salinan maklumat itu terlepas
segerak.

Nama pembolehubah adalah peka huruf besar-besaran. Secara teori, nama boleh ubah boleh dibuat daripada banyak
watak, tetapi makepp mungkin tidak akan dapat melihatnya jika anda melakukan apa-apa selain
aksara abjad angka, "_", dan "-".

Setiap makefile mempunyai set pembolehubahnya sendiri, dan menetapkan pembolehubah dalam satu makefile akan
tidak mempunyai kesan ke atas nilainya dalam mana-mana fail buatan lain. Jika anda ingin menetapkan pembolehubah
banyak makefiles, cara terbaik untuk melakukannya ialah dengan memastikan setiap daripadanya menyertakan takrifan yang sama
fail (lihat pernyataan sertakan) atau gunakan pembolehubah "global".

Pembolehubah Tugasan
Pembolehubah boleh menganggap nilai dalam beberapa cara yang berbeza:

· Pembolehubah boleh ditetapkan di dalam fail make. Terdapat beberapa cara yang berbeza untuk dilakukan
ini; lihat di bawah.

· Nilai pembolehubah boleh ditentukan pada baris arahan, seperti ini:

makepp CFLAGS=-O2 my_program

Jika lebih daripada satu fail make dimuatkan, pembolehubah CFLAGS disebarkan ke semua
makefiles. Pembolehubah yang ditetapkan pada baris arahan secara automatik mengatasi sebarang tetapan
pembolehubah dalam mana-mana makefiles.

Jika diperlukan, makefile mesti secara eksplisit mengatasi tetapan baris arahan.
Niatnya bukan untuk mengabaikan apa yang diminta pengguna, sebaliknya cara untuk mengubah suainya.
Pengubah suai "override" mungkin mendahului sebarang pernyataan tugasan. Tetapi dalam kes
penyataan kata kunci, susunan itu penting, itulah sebabnya varian penggantian adalah
selalu ditunjukkan di bawah. Pengubah suai "override" hanya digunakan pada mana-mana tugasan di mana ia
hadir, dan tidak mempengaruhi penetapan kemudian kepada pembolehubah.

· Jika pembolehubah ditetapkan dalam persekitaran, ia boleh dirujuk sebagai pembolehubah makepp.
Biasanya penetapan kepada pembolehubah di dalam makefile mengatasi tetapan daripada
persekitaran, tetapi anda boleh mengubahnya dengan menggunakan "-e" atau "--environment-overrides"
pilihan baris perintah.

Pembolehubah ditetapkan dengan salah satu daripada beberapa ungkapan tugasan, seperti ini

X = 1
MODUL := abcd
CC ?= gcc
CFLAGS += -Dinding
tentukan VAR
var baris 1
var baris 2
enddef
eksport PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = maklumat untuk dilihat dalam semua fail buatan

Ruang putih mendahului dan mengekori di sekeliling nilai sentiasa dilucutkan.

Pengendali tugasan yang berbeza mempunyai maksud yang agak berbeza.

Mudah tugasan pengendali

=
PEMBOLEH UBAH = rentetan teks
mengatasi VARIABLE = rentetan teks

Ini adalah kenyataan tugasan biasa yang semua pelaksanaan membuat sokongan. The
ungkapan di sebelah kanan tidak dinilai sehingga nilai "$(VARIABLE)" adalah
sebenarnya digunakan di suatu tempat. Oleh itu, jika anda melakukan perkara berikut:

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

Kemudian "$(Y)" kemudian dalam makefile akan menilai kepada "2".

Secara umum, anda biasanya mahu menggunakan ":=" (lihat di bawah) dan bukannya "=" kerana ia
menyediakan penilaian pembolehubah yang lebih boleh diramal. Walau bagaimanapun, ada kalanya anda memerlukan
untuk menangguhkan penilaian berubah. Juga, jika anda menulis makefile yang mesti
serasi ke belakang dengan beberapa versi make selain GNU make, maka anda tidak mempunyai
pilihan: anda hanya boleh menggunakan "=".

:=
PEMBOLEH UBAH := expr
mengatasi PEMBOLEH UBAH := expr

Ini sama dengan "VARIABLE = expr" kecuali sebelah kanan dinilai
sekali dan untuk semua pada masa tugasan. Justeru jika

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

maka "$(Y)" kemudian dalam makefile akan menilai kepada "1" kerana itulah "$(X)" adalah
apabila "$(Y)" ditakrifkan.

;=
PEMBOLEH UBAH ;= expr
mengatasi PEMBOLEH UBAH ;= expr

Ini adalah sama seperti "PEMBOLEH UBAH := expr" kecuali bahagian sebelah kanan dinilai
hanya pada masa penggunaan pertama dan kemudian teringat. Ini berguna untuk mahal
arahan, yang sentiasa mengembalikan nilai yang sama, tetapi yang anda tidak mahu lakukan apabila
membina sasaran yang tidak berkaitan:

VAR1 ;= $(perl pengiraan mahal)
VAR2 ;= $(arahan luaran shell)

Ambil perhatian bahawa makefiles lama biasanya akan menggunakan ":=" di sini, untuk sekurang-kurangnya melakukan ini sekali sahaja.
Tetapi dengan pengendali ini, anda juga boleh tidak melakukannya, jika anda tidak melakukannya pada masa ini
memerlukan nilai. Untuk nilai yang sama dalam beberapa direktori, anda boleh
mengoptimumkan ini lagi dengan "global", dibincangkan di bawah.

Walau bagaimanapun ini tidak bertujuan sebagai cara bijak untuk memaksa susunan penilaian. Sekiranya
pembolehubah yang ditakrifkan seperti ini termasuk nilai pembolehubah lain, dan yang lain
mempunyai nilai khusus sasaran, dan pengembangan pertama adalah untuk sasaran itu, kemudian
nilai khusus sasaran akan tetap untuk semua konteks lain juga. Ini adalah pepijat dan
semoga dapat diperbaiki pada masa akan datang.

+=
PEMBOLEH UBAH += expr
mengatasi VARIABLE += expr

Menambah rentetan pada kandungan sebelumnya pembolehubah, dipisahkan oleh ruang. Jika
pembolehubah telah ditetapkan sebelum ini dengan ":=", kemudian sebelah kanan dinilai
sebelum melampirkan.

&=
PEMBOLEH UBAH &= expr
mengatasi PEMBOLEH UBAH &= expr

Menandakan rentetan pada kandungan pembolehubah sebelumnya, dipisahkan oleh ruang.
Jika pembolehubah sebelum ini ditetapkan dengan ":=", maka sebelah kanan ialah
dinilai sebelum dilampirkan.

Contohnya satu cara untuk menjamin bahawa "CFLAGS", apa sahaja yang boleh dimasukkan oleh pengguna,
sentiasa bermula dengan "-Wall" ialah dua baris ini:

CFLAGS = -O2 # Mungkin ditindih pada baris arahan
mengatasi CFLAGS &= -Dinding # Disediakan tanpa syarat

Dalam makefiles lama anda biasanya perlu melakukan sesuatu seperti ini, yang mempunyai sisi
kesan memaksa jenis kepada ":=" untuk mengelakkan rekursi yang tidak berkesudahan:

PEMBOLEH UBAH := expr $(BOLEH UBAH)

?=
PEMBOLEH UBAH ?= expr
override VARIABLE ?= expr # Tidak berguna, tetapi sah

Menetapkan nilai pembolehubah, tetapi hanya jika pembolehubah tidak dinyatakan lebih awal dalam
makefile, pada baris arahan, atau dalam persekitaran. Tugasan di atas ialah
betul-betul setara dengan

ifndef PEMBOLEH UBAH
PEMBOLEH UBAH = expr
ENDIF

!=
PEMBOLEH UBAH != perintah shell
mengatasi VARIABLE != perintah shell

Menjalankan arahan shell dan menetapkan pembolehubah untuk mengandungi output standard arahan.
Ini betul-betul setara dengan

PEMBOLEH UBAH := $(arahan shell)

Berbilang talian pembolehubah

Pernyataan "define" ialah persamaan berbilang baris bagi pernyataan mudah di atas. The
operator selepas pembolehubah adalah pilihan. Jika tiada, ia bersamaan dengan "define VARIABLE
=". Pengendali "&=" dan "+=" sedikit berbeza di sini, kerana mereka melekatkan ini
nilai lama dengan baris baharu, bukannya ruang. Tidak boleh ada apa-apa kecuali a
komen selepas pernyataan, iaitu nilai bermula pada baris seterusnya.

takrifkan PEMBOLEH UBAH :=
baris pertama nilai pembolehubah
baris kedua nilai pembolehubah
baris ketiga nilai pembolehubah
endef

mengatasi takrif PEMBOLEH UBAH
...
enddef

Kata kunci sebelum "takrifkan" boleh menjadi gabungan salah satu daripada "eksport" atau "global" dan
"override".

Jika anda memerlukan nilai pembolehubah untuk mengandungi baris baharu, anda mesti menggunakan pernyataan "define" sebagai
ditunjukkan (atau anda boleh menetapkan nilai terus dalam Perl). ("endef" dipilih untuk
keserasian dengan GNU make. Anda juga boleh menggunakan "enddef".) Ini berguna terutamanya untuk
"urutan arahan dalam tin", contohnya, sesuatu seperti ini:

tentukan COMPILE_C_PROGRAM
@&echo "Menyusun $(input)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(TERMASUK) -c $(input) -o $(output)
endef

Kemudian anda boleh menggunakan pembolehubah berbilang baris ini dalam beberapa peraturan, seperti ini:

%.o : %.c
$(COMPILE_C_PROGRAM)

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

Ambil perhatian bahawa anda selalunya boleh mencapai kesan yang sama dengan menggunakan koma bernoktah dan bukannya baris baharu,
kerana shell mentafsirkannya sebagai pembatas perintah juga. Sebagai contoh,

COMPILE_C_PROGRAM = @echo "Menyusun $(input)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(TERMASUK) -c $(input) -o $(output)

akan mempunyai kesan yang sama, kecuali titik koma memaksa Perl untuk menghantarnya ke shell,
bukannya melaksanakan arahan secara langsung dan lebih cekap. Anda juga perlu meletakkan setiap satu
terbina pada barisnya sendiri, bermakna anda perlu beralih kepada gema luaran dalam
kes koma bertitik.

Terdapat satu kepakaran apabila mengembangkan dalam "define", iaitu "define X :=" atau pada a
pembolehubah yang sudah ":=", "define X &=" dan "define X +=". Dalam kes ini
"$(arahan shell ...)" atau terbina dalam "$(&command ...)" jangan dapatkan baris baharu diubah menjadi
ruang.

Mengeksport pembolehubah kepada subproses

eksport VAR ...
eksport VAR = nilai
mengatasi eksport VAR += nilai

Borang pertama menandakan pembolehubah yang diberikan untuk eksport ke subproses, dengan apa jua nilai
pembolehubah kemudian mempunyai. Bentuk kedua, yang digunakan hanya untuk satu pembolehubah, tambahan
memberikan nilai dengan segera. Semua varian tugasan dibenarkan.

Berkongsi pembolehubah seluruh makefiles

VAR global...
VAR global = nilai
mengatasi nilai VAR &= global

Borang pertama menandakan pembolehubah yang diberikan sebagai global kepada semua makefiles. Jika ada di antara mereka
sudah mempunyai nilai, nilai itu dipindahkan daripada pembolehubah tempatan makefile ke global
satu. Walau bagaimanapun, jika, pada masa kenyataan ini dilihat, mana-mana fail buatan lain sudah mempunyai a
nilai untuk mana-mana daripada mereka, maka makefile tersebut tidak akan melihat yang global.

Bentuk kedua, yang digunakan hanya untuk satu pembolehubah, juga memberikan hak nilai
jauh. Semua varian tugasan dibenarkan. Ambil perhatian bahawa ":=" akan berkembang serta-merta
kepada nilai dalam makefile tempatan. Sebaliknya "=" pembolehubah akan berkembang ke
nilai pada titik penggunaan.

Pembolehubah global boleh menjadi sukar untuk ditangani, kerana makepp boleh memuatkan fail make dalam mana-mana
perintah, memandangkan keperluan timbul untuk membina beberapa sasaran yang tidak ada peraturan atau fail buatan dimuatkan.
Atas sebab ini adalah disyorkan untuk mempunyai a RootMakeppfile dan untuk memuatkan semua secara eksplisit
yang lain yang mengubah suai atau menggunakan pembolehubah dengan "load-makefile".

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

Juga ambil perhatian bahawa projek anda mungkin suatu hari nanti akan dibina bersama-sama dengan projek lain. Untuk ini
sebab adalah disyorkan untuk sentiasa menjadikan nama projek sebahagian daripada mana-mana nama pembolehubah global.

Khusus sasaran tugasan

sasaran: VARIABLE = rentetan
sasaran: VARIABLE := string
sasaran: mengatasi VARIABLE += rentetan

Menetapkan nilai sasaran khusus pembolehubah. Nilai khusus sasaran sedang berkuat kuasa hanyalah
dalam tindakan yang menghasilkan sasaran yang diberikan. Ini digunakan terutamanya untuk perkara seperti
ini:

CFLAGS := -O2

my_prog: file1.o file2.o special_file.o

special_file.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

Apa yang berlaku di sini ialah semua fail ".c" akan disusun dengan pengoptimuman ("-O2") kecuali
"special_file.c", yang disusun dalam mod nyahpepijat ("-g"). Ini adalah cara yang mudah untuk
tentukan pilihan kompilasi yang berbeza untuk beberapa fail sahaja.

Tugasan pembolehubah khusus sasaran seperti ini hanya digunakan pada tindakan peraturan; mereka
tidak berkuat kuasa semasa menilai sasaran atau kebergantungan peraturan. Jika peraturan
mempunyai lebih daripada satu sasaran, tugasan pembolehubah khusus sasaran diambil hanya daripada
pertama sasaran. Juga ambil perhatian bahawa pembolehubah khusus sasaran makepp sedikit berbeza
daripada GNU make's kerana ia hanya terpakai pada peraturan untuk satu fail yang disebutkan, dan bukan kepada
mana-mana pendahulunya.

Pengembangan kad liar dilakukan pada sasaran, jadi anda boleh melakukan sesuatu seperti ini:

ujian_*.o : CFLAGS += -DTEST

Untuk keserasian dengan GNU make, "%" boleh digunakan sebagai ganti "*".

Pembolehubah Penggantian
Peraturan penggantian pembolehubah Makepp adalah serupa dengan peraturan pembuatan lain, tetapi agaknya
lebih berkuasa. Seperti dalam semua pembuatan, "$(CC)" atau "${CC}" kedua-duanya mewakili nilai
pembolehubah CC. Jika anda memerlukan tanda dolar literal, letakkan tanda dolar berganda ($$), seperti
ini:

sasaran: dep1 dep2 dep3 dep4
&rm -f $(output)
untuk fail dalam $(inputs); buat kucing $$file >> $(output); selesai

Selain itu makepp mempunyai sintaks "$[VARIABLE]", yang melakukan perkara yang sama seperti yang lain
dua, tetapi sebelum makepp groks apa-apa lagi. Ini membolehkan menggunakannya untuk peraturan yang lengkap
dan/atau syarat:

define bracket_rule =
ifdef SOME_VAR
kurungan:
&echo ini ialah peraturan -o $(output)
ENDIF
enddef

$[bracket_rule]

gaya rc penggantian

Secara lalai, makepp menggunakan penggantian gaya rc (dipanggil sedemikian kerana ia dipelopori oleh
rc shell). Ini paling baik digambarkan oleh contoh:

MODUL = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(sasaran)

Awalan "module_dir/" ditambahkan pada setiap perkataan dalam MODUL dan akhiran ".o" ialah
dilampirkan pada setiap perkataan.

Anda juga boleh menggunakan penggantian gaya rc tanpa meletakkan senarai perkataan ke dalam a
pembolehubah; sintaksnya ialah "$( word1 word2)". Perhatikan ruang antara kurungan dan
perkataan pertama. Jadi contoh di atas boleh ditulis sebagai:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(sasaran)

Pembolehubah akan memberikan penggantian gaya rc hanya apabila terdapat lebih daripada satu perkataan di dalamnya.
Dengan satu perkataan ia seperti buatan tradisional. Malangnya, apabila pembolehubah kosong, terdapat a
konflik. Pembuatan tradisional hanya mengembangkannya kepada rentetan kosong. Tetapi apabila anda fikirkan
sebagai senarai, anda mahu "-I$(DIRLIST)" hilang, bukan untuk memberikan "-I" yang sunyi. The
penyelesaiannya ialah membungkusnya ke dalam senarai yang bermula dengan ruang: "-I$( $(DIRLIST))" memberi anda
sama banyak pilihan, kerana terdapat perkataan dalam senarai.

Jika anda meletakkan beberapa pembolehubah dalam perkataan yang sama yang berkembang kepada tatasusunan perkataan, rc-style
penggantian sebenarnya mengambil produk cartesian, jadi anda boleh melakukan sesuatu seperti ini jika
awak mahu:

DIRS = s1 s2
MODUL = abc
AKHIRAN = .o .c
FAIL := $(DIRS)/$(MODUL)$(AKHIR)

dan FILES akan mengandungi rentetan

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

Selain ruang putih, penggantian gaya rc berhenti pada sebarang petikan, sebarang bulat, kerinting atau segi empat sama
kurungan, dan mana-mana ", : ; = # @". Ambil perhatian bahawa ini mungkin mengejutkan, dan sekali lagi diperlukan
senarai yang jelas. Katakan anda mahu mencari pengepala mengikut kad bebas dalam semua direktori
bermula dengan huruf besar:

BURUK := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
BAIK := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Jika penggantian gaya rc menghalang, atau jika anda perlu mempunyai pendahuluan atau mengekori
ruang kosong dalam pembolehubah buat anda, kemudian anda boleh mematikan penggantian gaya rc dengan menetapkan
pembolehubah "makepp_simple_concatenation=1". Anda boleh mematikannya secara global atas arahan
garis atau sebagai pembolehubah persekitaran. Atau berdasarkan per-makefile dengan menetapkan pembolehubah masuk
makefile anda. Anda harus melakukan ini berhampiran bahagian atas makefile, jika tidak, anda mungkin terserempak
situasi lucu di mana penggantian gaya rc digunakan untuk beberapa penilaian dan bukan yang lain.
(Semua ungkapan yang dinilai sebelum tugasan akan menggunakan penggantian gaya rc, dan semua
ungkapan yang dinilai selepas tidak akan. Sejak masa penilaian ungkapan dalam
makefiles adalah rumit dan tidak selalu jelas daripada susunan pernyataan dalam
makefile, sebaiknya tetapkan "makepp_simple_concatenation" seawal mungkin.) Anda boleh
malah menetapkannya hanya untuk satu sasaran:

sasaran: makepp_simple_concatenation = 1
sasaran:
&echo before_first$(LIST)after_last -o $(output)

Kerana "$[VARIABLE]" dinilai lebih awal daripada "$(VARIABLE)", menggabungkan kedua-duanya dalam rc-
penggantian tidak akan memberikan hasil yang anda jangkakan, melainkan anda membungkusnya dengan eksplisit
senarai:

A = ab
N = 1 2
BURUK := $(A)$[N]
BAIK := $(A)$( $[N])

Baris terakhir dibaca sebagai

BURUK := $(A)1 2 # a1 b1 2
BAIK := $(A)$( 1 2) # a1 a2 b1 b2

Penggantian Rujukan

Rujukan penggantian mempunyai bentuk "$(VAR:A=B)", dengan A ialah corak untuk dipadankan dan B ialah
corak untuk menggantikannya. Rujukan penggantian ialah singkatan bagi
fungsi "patsubst". Sebagai contoh:

source_files = ac bc cc dc
object_files = $(source_files:%.c=%.o)

akan menetapkan "$(object_files)" kepada "ao bo co do". "%" ialah padanan aksara khas
sebarang rentetan sewenang-wenangnya. Jika kedua-dua A dan B bermula dengan "%", kes biasa apabila menggantikan
akhiran, mereka boleh ditinggalkan:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # sama, kerana . tidak istimewa

Whitespace in pembolehubah

Jika anda perlu mengawal ruang putih dalam pembolehubah, anda mesti (pada masa ini) melumpuhkan gaya rc
penggantian (dengan menetapkan "makepp_simple_concatenation=1") dan kemudian gunakan sintaks seperti ini:

null =
T = -o $(null)

atau, dengan penilaian kosong:

T = -o $()

Apabila anda melakukan ini, pembolehubah "T" mengandungi "-o" diikuti dengan ruang.

Teknik jenis ini untuk mengendalikan ruang kosong tidak disyorkan. Jika anda memerlukan pembolehubah
dalam fail make anda untuk mengandungi ruang, anda harus berfikir secara serius tentang perkara yang anda lakukan.
Jika anda perlu mengendalikan ruang, biasanya lebih baik untuk meletakkan kod Perl ke dalam anda
makefile untuk mengurusnya (menggunakan pernyataan "perl_begin" atau "sub"), atau untuk mengendalikannya
dalam pernyataan shell dalam tindakan peraturan.

Kes ini biasanya timbul apabila orang cuba menggunakan peraturan yang sama untuk kaedah yang berbeza
seni bina yang tidak menggunakan sintaks perintah Unix biasa. Contohnya, kadang-kadang seseorang melihat
perkara seperti ini dalam makefiles:

ifeq ($(ARCH),weirdarch)
O := /OUTPUT=
lagi
null :=
O := -o $(null)
ENDIF

%.o : %.c
$(COMPILER) $(input) $(O)$(output)

Anda boleh melakukan ini dengan makepp jika anda benar-benar mahu, tetapi anda mungkin akan mendapati bahawa anda
makefiles jauh lebih mudah dibaca jika anda mempunyai pembolehubah yang kurang rumit
penggantian, cth,

ifeq ($(ARCH),weirdarch)
%.o : %.c
$(WEIRD_COMPILER) $(input) /OUTPUT=$(output)
lagi
%.o : %.c
$(CC) -c $(input) -o $(output)
ENDIF

Ruang putih tidak dibenarkan dalam nama pembolehubah, hanya dalam nilainya. Ini berbeza
daripada beberapa membuat pelaksanaan.

automatik Pembolehubah
Pembolehubah automatik ialah pembolehubah yang menganggap nilai berbeza bergantung pada peraturan mana
ia dinilai. Makepp menyokong kebanyakan pembolehubah automatik yang lain
versi guna. Di samping itu, ia mempunyai nama yang kurang samar, lebih panjang untuk kebanyakan mereka
yang boleh anda gunakan sebaliknya. (Untuk fail buatan warisan yang berlaku untuk mentakrifkan semula nama ini, the
takrifan dalam makefile mengatasi makna lalai. Sebagai contoh, jika anda berkata
"target = abc" dalam fail make anda, kemudian "$(target)" akan sentiasa berkembang kepada "abc", dan tidak akan
lebih lama bersamaan dengan $@.)

Berikut ialah senarai lengkap semua pembolehubah automatik yang disokong oleh makepp:

output
sasaran
$@ Sasaran peraturan semasa. Sebenarnya, kerana makepp menyokong pelbagai sasaran untuk
mana-mana peraturan, ini adalah pertama sasaran. Sebagai contoh, dalam peraturan berikut

y.tab.c y.tab.h : parser.y
$(YACC) -o $(output) $(YFLAGS) $(input)

"$(output)" akan mengandungi nilai y.tab.c. Oleh kerana pembolehubah ajaib ini sebenarnya
fungsi, anda juga boleh lulus indeks sebagai argumen. Ini dikira dari 1 atau ke belakang
dari -1. Jadi "$(output 2)" atau "$(output -1)" akan mengandungi nilai y.tab.h.

Walaupun ketiga-tiga bentuk pembolehubah ini mempunyai nilai yang sama, terdapat perbezaan dalam
tafsiran untuk peraturan berbilang sasaran. Jika anda menggunakan nama samar gaya lama $@,
makepp akan mentafsirkannya sebagai set peraturan gaya lama, bukannya peraturan moden itu
menghasilkan semua sasaran tersebut dalam satu masa:

ab: # benar-benar: satu peraturan setiap satu untuk a dan b
sentuh $@

cd: # ralat: mpp mengadu bahawa ini tidak membina d
sentuh $(output)

output
sasaran
Semua sasaran peraturan semasa. Sama seperti "$(target)" melainkan terdapat lebih daripada satu
sasaran. Dalam contoh di atas, "$(outputs)" ialah y.tab.c y.tab.h. Anda boleh lulus an
senarai indeks, jadi "$(outputs 2 1)" akan menjadi y.tab.h y.tab.c.

pergantungan
input
$< Kebergantungan eksplisit pertama peraturan. Sebagai contoh, dalam peraturan ini

%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

"$(input)" akan menjadi nama bagi .c fail, tidak kira apa .h fail makepp
menemui. Jika anda menentukan lebih daripada satu pergantungan, anda boleh mendapatkannya dengan melepasi satu
indeks: "$(input $(INDEX))" ialah kebergantungan INDEX.

kebergantungan
input
$^ Semua kebergantungan eksplisit sasaran, tidak termasuk .h fail ditemui oleh
makepp_scanning untuk termasuk.

Sebagai contoh, dalam peraturan

myprog.o : *.o
$(CC) $(CFLAGS) $(input) -o $(output)

"$(inputs)" akan menjadi semua fail .o dalam direktori. Anda boleh memilih yang anda sahaja
mahu dengan melepasi senarai indeks. Jika anda menyatakan secara eksplisit jenis fail yang berbeza,
anda boleh memilihnya seperti dalam "$(input 2 3 4)" (tetapi dengan kad bebas ini tidak terlalu
menjanjikan).

sorted_dependencies
sorted_inputs
$+ Semua kebergantungan sasaran, dalam susunan yang disusun, dengan pendua dialih keluar.
Bersamaan dengan "$(sort $(inputs))".

berubah_bergantung
ditukar_input
$? Kebergantungan sasaran yang telah berubah. Ini termasuk hanya secara eksplisit
dependencies (iaitu, yang anda senaraikan dalam makefile), tidak ditemui secara tersirat
kebergantungan daripada pengimbasan (seperti fail .h).

Ini biasanya digunakan dalam arahan seperti ini:

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

iaitu, ar diberitahu untuk menggantikan hanya modul yang telah berubah. (Perhatikan
"ignore_action" membina peraturan semak. Jika anda tidak menyatakan ini, makepp akan memaksa
tindakan yang akan dilaksanakan apabila ia berubah. Jika tiada kebergantungan telah berubah, the
rentetan tindakan akan menjadi "ar ru libmine.a" yang mungkin berbeza daripada yang sebelumnya
kali terakhir anda menjalankannya, jadi tanpa "ignore_action" makepp akan melaksanakannya. Di dalam ini
kes, ia tidak berbahaya, tetapi dengan arahan lain, ia boleh menjadi masalah. Lihat
makepp_build_check untuk butiran tentang "ignore_action".)

Membina arkib seperti ini bukanlah idea yang baik kerana ia akan mengurangkan binaan anda
boleh dipercayai. Masalahnya ialah jika anda membina arkib, kemudian keluarkan salah satu daripadanya
modul daripada senarai MODUL, modul akan tetap berada dalam arkib dan
makepp

berpunca
$* Batang dalam peraturan corak (iaitu, apa sahaja '%' yang dipadankan). Sebagai alternatif, jika ini
bukan peraturan corak, mengembalikan nama fail tanpa sambungan (iaitu, ia
bersamaan dengan "$(nama asas $(input))".

Ini kebanyakannya untuk keserasian ke belakang. Sebagai contoh, dalam versi lama make the
satu-satunya cara untuk memberitahunya bagaimana untuk menyusun mana-mana .c fail ke dalam yang sepadan .o fail adalah seperti
ini:

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

Ini adalah cara yang buruk untuk menulis peraturan. Ia lebih jelas untuk menggunakan gaya buatan GNU
peraturan corak, seperti ini:

%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

foreach
Nama fail semasa daripada klausa "foreach". klausa "foreach" jarang digunakan,
tetapi ia adalah jenis peraturan corak paling umum yang disokong oleh makepp. Untuk
contohnya,

#
# Bina fail .c dengan sejenis prapemproses khas:
#
%.c : %.k
$(prapemproses) $(input) > $(output)

#
# Susun fail .c ke dalam fail .o:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

#
# Bendera kompilasi ganti khas untuk fail .c yang diterbitkan
# daripada fail .k:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c): foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(input) -o $(output)

Lihat dokumentasi pada klausa foreach dalam peraturan untuk butiran lanjut dan contoh.

$/ Ini pada asasnya pemalar, sama ada "/", atau pada Windows asli "\". Anda memerlukannya, jika
anda ingin memulakan program secara mudah alih, contohnya yang anda bina dalam direktori semasa:

keluaran saya:
.$/myprog >$(output)

Untuk nama fail yang diluluskan sebagai hujah, ia tidak begitu diperlukan kerana Windows boleh mengendalikan Unix
sintaks di sana.

Lebih Baik Pembolehubah
Anda boleh menetapkan ini dalam semua cara yang dijelaskan di atas (kecuali jika dinyatakan sebaliknya) untuk mengubah suai
bahaviour of makepp. Secara lalai semuanya tidak ditentukan.

MAKEPP_DEBUG
Jika anda mengeksport ini dengan nilai sebenar sebelum memanggil makepp, anda mendapat lebih banyak penyahpepijatan
info. Ini ialah "RULE_SOURCE" fail yang dibina semasa ini berkuat kuasa di bawah
makeppinfo, mppi dan butiran tentang pengembangan pembolehubah dan padanan peraturan di bawah
makepplog, mppl. Ini juga akan menunjukkan kepada anda jika makepp kehabisan memori atau hang,
kerana ia tidak berkesudahan mengembangkan pembolehubah yang sama:

A = $A # penilaian tertunda, perlu :=
B = $C
C = $B

MAKEPP_LN_CP
Lihat nota di bawah &ln.

makepp_percent_subdirs
Tetapkan ini kepada beberapa nilai sebenar (seperti 1) untuk mempunyai "%" dalam sasaran atau kebergantungan padanan
merentas lebih daripada satu direktori.

makepp_require_phony
Tetapkan ini kepada beberapa nilai sebenar (seperti 1) untuk mengelakkan kepalsuan tersirat (iaitu jika peraturan
berjaya tanpa menghasilkan sasarannya). Pembolehubah ini sepatutnya benar secara lalai, kepada
mengelakkan rantai pergantungan yang terputus, tetapi itu akan memecahkan keserasian ke belakang dengan
makefiles ceroboh.

makepp_signature_C_flat
Ini ialah pilihan untuk tandatangan C. Tetapkan ini kepada beberapa nilai sebenar (seperti 1) untuk merawat anda
sumber sebagai diratakan, iaitu semua baris baharu (kecuali di sekitar pernyataan prapemproses) adalah
dianggap seperti ruang kosong dan arahan "#line" diabaikan.

makepp_simple_concatenation
Tetapkan ini kepada beberapa nilai sebenar (seperti 1) untuk mengelakkan "penggantian gaya rc".

mutiara
Anda boleh menetapkan ini kepada perl tepat yang anda gunakan untuk menjalankan skrip dalam makepp
suite, dan eksportnya. Ini boleh membantu untuk menjalankan subskrip dengan perl yang sama. Ini adalah
kebanyakannya berguna untuk suite ujian, pemasangan dan untuk binaan rekursif.

VPATH
Menetapkan pembolehubah ini kepada beberapa nilai secara tersirat memanggil "nilai % vpath".

Predefined Pembolehubah
Makepp mentakrifkan beberapa pembolehubah, yang boleh anda ganti:

AR default: "ar".

ARFLAGS
default: "rv".

AS default: "sebagai".

CC default: Yang pertama ditemui antara "gcc", "egcc", "pgcc", "c89" atau "cc", atau pada Windows
tambahan "cl" atau "bcc32".

CFLAGS
default: Jika "$(CC)" ialah pengkompil GNU "-g -Wall", jika ia adalah salah satu daripada dua Windows
tidak menyusun apa-apa, jika tidak "-g".

CURDIR
Direktori di mana Makefile semasa berada.

CXX default: Yang pertama ditemui antara "g++", "c++", "pg++", "cxx", "C""C" atau "aCC", atau pada
Windows tambahan "cl" atau "bcc32".

CXXFLAGS
default: Jika "$(CXX)" ialah pengkompil GNU "-g -Wall", jika ia adalah salah satu daripada dua Windows
tidak menyusun apa-apa, jika tidak "-g".

F77 default: Yang pertama ditemui antara "f77", "g77" atau "fort77".

FC default: "$(F77)".

LD default: "ld".

LEX default: Yang pertama ditemui di kalangan "lex" atau "flex".

LIBTOOL
default: "libtool".

JADIKAN
Pembolehubah ini mempunyai dua nilai yang berbeza, bergantung pada kehadiran atau tidak
"--tradisional-rekursif-buat". Makepp mengenali apabila pembolehubah ini digunakan dan
mematikan beberapa ciri, walaupun sebelum pengulangan benar-benar berlaku. Ini boleh jadi
tidak diingini semasa anda menghapuskannya secara beransur-ansur, jadi mula-mula tukar panggilan kepada a
makepp khusus "$((MAKE))", yang tidak akan mematikan ciri. Anda tidak sepatutnya menetapkannya
kerana itu mematahkan kerja rekursi pintar kami.

MAKECMDGOALS
Pembolehubah ini ditetapkan tetapi tidak digunakan oleh makepp. Anda boleh menanyakannya untuk melakukan sesuatu hanya jika
sasaran tertentu telah diminta.

default: Apa sahaja sasaran eksplisit yang diberikan oleh pengguna (atau seruan rekursif).
Kosong apabila membina sasaran lalai secara tersirat.

ifneq $(tapis sasaran khas, $(MAKECMDGOALS))
# sasaran khas ialah salah satu daripada sasaran eksplisit semasa
else ifeq $(MAKECMDGOALS)
# tiada sasaran yang jelas
ENDIF

MAKEFLAGS (dieksport)
Pilihan standard yang mana makepp dipanggil. Mereka yang mempunyai satu huruf
borang digabungkan pada permulaan tanpa petunjuk "-" (syurga tahu mengapa gmake memilih
untuk menggugurkan "-").

MAKEINFO
default: "makeinfo".

MAKEPPFLAGS (dieksport)
Ini ditetapkan kepada nilai yang sama seperti MAKEFLAGS, tetapi hanya jika pembolehubah ini terdapat dalam
persekitaran makepp.

_MAKEPPFLAGS (dieksport)
Pilihan khusus makepp yang diperlukan untuk keserasian POSIX/gmake, yang mana makepp
telah dipanggil. Ini berada dalam pembolehubah yang berasingan supaya fail makefile lama tidak boleh pecah
keserasian dengan menyahset MAKEFLAGS. Ini hanya ditetapkan dengan
"--tradisional-rekursif-buat".

MAKEPP_VERSION
Versi makepp yang anda jalankan. Jika ia adalah versi beta, ia akan mempunyai a
tanda sempang diikuti dengan YYMMDD serta beberapa lagi data dalaman. Anda boleh menggunakan ini untuk "ifdef"
untuk menyembunyikan binaan khusus makepp daripada buatan lain.

default: Nilai yang sama dipaparkan oleh "makepp --version"

JKR Alias ​​untuk "CURDIR".

RM default: "rm -f". Ini dimaksudkan untuk Makefiles lama. Untuk yang baru seeloknya guna
arahan &rm terbina secara langsung. Jika anda ingin menulis peraturan bersih palsu, lihat
arahan "makeppclean -r" sebaliknya.

ROOT
Laluan relatif kepada akar sistem binaan anda, iaitu direktori lebih jauh ke dalam
yang anda mempunyai "RootMakeppfile(.mk)". Jika anda tidak mempunyai satu, pembolehubah ini ialah
kosong.

SHELL
Pembolehubah ini hanya dihormati jika anda "mengeksport"nya. Dalam kes itu ia adalah Shell
yang digunakan untuk melaksanakan tindakan bukan terbina dengan beberapa watak istimewa di dalamnya (plain
yang dilaksanakan secara langsung). Pada Windows Strawberry atau ActiveState Perl, jika anda ada
Shell seperti Unix, sebaliknya anda mesti menetapkan pembolehubah SHELL anda kepada nilai yang berakhir dengan "sh"
atau "sh.exe" sebelum memanggil makepp.

default: Yang pertama ditemui di kalangan "/usr/xpg4/bin/sh" (cth Solaris) atau "/sbin/xpg4/sh"
(cth Reliant Unix) atau "/ Bin / sh".

YACC
default: Yang pertama ditemui di kalangan "bison -y" atau "yacc".

Pembolehubah and Perl
Nilai pembolehubah disimpan sebagai skalar Perl biasa, jadi anda boleh mengaksesnya terus daripada
Kod Perl jika anda perlu melakukan sebarang manipulasi rumit dengan mereka; lihat makepp_extending
untuk maklumat lanjut.

Mengakses pembolehubah global daripada Perl dicapai dengan meletakkan awalannya dengan "Mpp::global"
pakej. Malah mana-mana pembolehubah, belum ada dalam makefile semasa, dan yang anda
serahkan kepada dalam pakej ini akan mula menjadi global, seolah-olah anda baru sahaja mengeluarkan
kenyataan "global" untuknya.

Akses langsung ini bagaimanapun terdedah kepada ralat! Pengguna mungkin telah mengatasi pembolehubah ini
pada baris arahan atau melalui persekitaran. Beberapa fail make lain dimuatkan sebelum ini
seseorang mungkin telah menjadikan pembolehubah global atau sasaran khusus. Dalam kes ini anda tidak akan melakukannya
cari nilai pembolehubah, atau apabila menetapkannya, mungkin menghilangkan sifatnya
(bersamaan dengan pengubah suai "override", kecuali untuk spesifik sasaran.)

Dengan akses terus anda juga memintas pengembangan pembolehubah ini, jika ia adalah jenis
"=" atau ";=". Pembolehubah khas seperti "$(CC)" bermula sebagai fungsi, sehingga ia berfungsi
ditugaskan untuk. Jadi dalam banyak kes anda tidak akan melihat nilainya.

Atas sebab-sebab ini adalah lebih baik untuk membiarkan makepp menentukan nilai yang betul. Anda boleh menggunakan
varian "makeperl", di mana pembolehubah telah dinilai sebelum kod Perl mendapat
ditafsirkan:

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

Jika anda memerlukan pembolehubah dalam blok perl makefile ini dicapai melalui pembolehubah Perl
$makefile seperti berikut:

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

Fungsi sentiasa menghantar objek makefile sebagai argumen kedua $_[1]:

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

Perintah sepatutnya dipanggil dalam tindakan peraturan, di mana objek makefile berada
boleh diakses melalui "$Mpp::Subs::rule->{MAKEFILE}":

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

Gunakan makepp_variables dalam talian menggunakan perkhidmatan onworks.net