makepp_variables - Online di Cloud

PROGRAM:

NAMA

makepp_variables -- Cara menggunakan variabel di makepp

DESKRIPSI

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAG,
SEBAGAI, C: cc,
CFLAG,
"berubah_dependensi",
berubah_input,
KURDIR,
CXX,
CXXFLAG, D: "ketergantungan",
"ketergantungan", F: F77,
FC,
"untuk setiap", I: memasukkan,
input, L: LD,
LEX,
LIBTOOL, M: MEMBUAT,
TUJUAN BUAT CMD,
MAKEFLAG,
INFO,
MAKEPP_DEBUG,
MAKEPPFLAG,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "keluaran",
"keluaran", P: PERL,
PD, R: RM,
AKAR, S: KERANG,
"sorted_dependencies",
diurutkan_input,
"tangkai", T: target,
target, V: VPATH, Y: YACC

Makefile biasanya menggunakan variabel di banyak tempat. Salah satu alasan penting untuk menggunakan
variabel adalah untuk memastikan bahwa informasi terkandung hanya di satu tempat di makefile, jadi
bahwa jika itu berubah, tidak ada bahaya dari dua salinan informasi yang keluar
sinkronisasi.

Nama variabel peka huruf besar/kecil. Secara teori, nama variabel dapat dibuat dari banyak
karakter, tetapi makepp mungkin tidak akan bisa grok jika Anda melakukan hal lain selain
karakter alfanumerik, "_", dan "-".

Setiap makefile memiliki kumpulan variabelnya sendiri, dan menyetel variabel dalam satu makefile akan
tidak berpengaruh pada nilainya di makefile lainnya. Jika Anda ingin mengatur variabel
banyak makefile, cara terbaik untuk melakukannya adalah masing-masing menyertakan definisi umum
file (lihat pernyataan include) atau gunakan variabel "global".

Variabel Penugasan
Sebuah variabel dapat mengasumsikan nilai dalam beberapa cara yang berbeda:

· Sebuah variabel dapat diatur di dalam makefile. Ada sejumlah cara berbeda untuk dilakukan
ini; Lihat di bawah.

· Nilai variabel dapat ditentukan pada baris perintah, seperti ini:

makepp CFLAGS=-O2 program_saya

Jika lebih dari satu makefile dimuat, variabel CFLAGS disebarkan ke semua
makefile. Variabel yang diatur pada baris perintah secara otomatis menimpa pengaturan apa pun dari
variabel di salah satu makefile.

Jika diperlukan, makefile pada gilirannya harus secara eksplisit mengesampingkan pengaturan baris perintah.
Tujuannya bukan untuk mengabaikan apa yang diminta pengguna, melainkan cara untuk memodifikasinya.
Pengubah "override" dapat mendahului pernyataan penetapan apa pun. Tetapi dalam kasus
pernyataan kata kunci, urutannya penting, itulah sebabnya varian override adalah
selalu ditampilkan di bawah. Pengubah "override" hanya berlaku untuk tugas apa pun yang
hadir, dan tidak mempengaruhi penugasan selanjutnya ke variabel.

· Jika sebuah variabel diatur dalam lingkungan, itu dapat direferensikan sebagai variabel makepp.
Biasanya penetapan ke variabel di dalam makefile menimpa pengaturan dari
lingkungan, tetapi Anda dapat mengubahnya dengan menggunakan "-e" atau "--environment-override"
opsi baris perintah.

Variabel ditugaskan dengan salah satu dari beberapa ekspresi penugasan, seperti ini

X = 1
MODUL := abcd
CC ?= gcc
CFLAGS += -Dinding
tentukan VAR
garis var 1
garis var 2
pertahanan akhir
ekspor PATH := $(PWD):$(PATH)
global MYPROJECT.INFO = info untuk dilihat di semua makefile

Spasi awal dan akhir di sekitar nilai selalu dihilangkan.

Operator penugasan yang berbeda memiliki arti yang agak berbeda.

Sederhana tugas operator

=
VARIABEL = string teks
menimpa VARIABEL = string teks

Ini adalah pernyataan penugasan yang biasa bahwa semua implementasi membuat dukungan. NS
ekspresi di sisi kanan tidak dievaluasi sampai nilai "$(VARIABLE)" adalah
benar-benar digunakan di suatu tempat. Jadi, jika Anda melakukan hal berikut:

X = 1
kamu = $(X)
X = 2

Kemudian "$(Y)" nanti di makefile akan dievaluasi menjadi "2".

Secara umum, Anda biasanya ingin menggunakan ":=" (lihat di bawah) alih-alih "=" karena itu
memberikan evaluasi variabel yang lebih dapat diprediksi. Namun, ada kalanya Anda membutuhkan
untuk menunda evaluasi variabel. Juga, jika Anda menulis makefile, itu harus
kompatibel dengan beberapa versi merek selain merek GNU, maka Anda tidak memiliki
pilihan: Anda hanya dapat menggunakan "=".

:=
VARIABEL := expr
timpa VARIABEL := expr

Ini sama dengan "VARIABEL = expr" kecuali bahwa sisi kanan dievaluasi
sekali dan untuk semua pada saat penugasan. Jadi jika

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

lalu "$(Y)" nanti di makefile akan dievaluasi menjadi "1" karena itulah "$(X)" itu
ketika "$(Y)" didefinisikan.

;=
VARIABEL ;= expr
timpa VARIABEL ;= expr

Ini sama dengan "VARIABEL := expr" kecuali bahwa sisi kanan dievaluasi
hanya pada saat penggunaan pertama dan kemudian diingat. Ini berguna untuk yang mahal
perintah, yang selalu mengembalikan nilai yang sama, tetapi Anda tidak ingin melakukannya saat
membangun target yang tidak terkait:

VAR1 ;= $(perl perhitungan mahal)
VAR2 ;= $(perintah eksternal shell)

Perhatikan bahwa makefile lama biasanya akan menggunakan ":=" di sini, setidaknya untuk melakukan ini hanya sekali.
Tetapi dengan operator ini Anda bahkan tidak dapat melakukannya, jika saat ini Anda tidak melakukannya
membutuhkan nilai. Untuk nilai yang identik di beberapa direktori, Anda dapat
mengoptimalkan ini lebih lanjut dengan "global", dibahas di bawah.

Namun ini tidak dimaksudkan sebagai cara cerdas untuk memaksakan urutan evaluasi. Jika sebuah
variabel yang didefinisikan seperti ini termasuk nilai variabel lain, dan yang lain itu
memiliki nilai spesifik target, dan ekspansi pertama adalah untuk target itu, lalu
nilai spesifik target akan tetap untuk semua konteks lain juga. Ini adalah bug dan
semoga kedepannya bisa diperbaiki.

+=
VARIABEL += expr
menimpa VARIABEL += expr

Menambahkan string ke konten variabel sebelumnya, dipisahkan oleh spasi. Jika
variabel sebelumnya ditetapkan dengan ":=", kemudian sisi kanan dievaluasi
sebelum menambahkan.

&=
VARIABEL &= expr
menimpa VARIABEL &= expr

Menambahkan string ke konten variabel sebelumnya, dipisahkan oleh spasi.
Jika variabel sebelumnya ditetapkan dengan ":=", maka ruas kanan adalah
dievaluasi sebelum ditambahkan.

Misalnya salah satu cara untuk menjamin bahwa "CFLAGS", apa pun yang dimasukkan pengguna,
selalu dimulai dengan "-Wall" adalah dua baris ini:

CFLAGS = -O2 # Mungkin diganti pada baris perintah
override CFLAGS &= -Wall # Tanpa syarat ditambahkan

Di makefile lama Anda biasanya harus melakukan sesuatu seperti ini, yang memiliki sisi
efek memaksa tipe ke ":=" untuk mencegah rekursi tanpa akhir:

VARIABEL := expr $(VARIABEL)

?=
VARIABEL ?= expr
menimpa VARIABEL ?= expr # Tidak berguna, tetapi legal

Menetapkan nilai variabel, tetapi hanya jika variabel tidak ditentukan sebelumnya dalam
makefile, pada baris perintah, atau di lingkungan. Tugas di atas adalah
persis sama dengan

VARIABEL ifndef
VARIABEL = ekspr
endif

!=
VARIABEL != perintah shell
timpa VARIABEL != perintah shell

Jalankan perintah shell dan setel variabel untuk memuat output standar perintah.
Ini persis sama dengan

VARIABEL := $(perintah shell)

multiline variabel

Pernyataan "define" adalah padanan multiline dari pernyataan sederhana di atas. NS
operator setelah variabel adalah opsional. Jika tidak ada, itu sama dengan "define VARIABLE
=". Operator "&=" dan "+=" sedikit berbeda di sini, karena mereka menempelkannya ke
nilai lama dengan baris baru, bukan spasi. Tidak boleh ada apa-apa kecuali a
komentar setelah pernyataan, yaitu nilai dimulai pada baris berikutnya.

tentukan VARIABEL :=
baris pertama dari nilai variabel
baris kedua dari nilai variabel
baris ketiga dari nilai variabel
endef

menimpa mendefinisikan VARIABEL
...
pertahanan akhir

Kata kunci sebelum "define" dapat berupa kombinasi dari salah satu dari "ekspor" atau "global" dan
"mengesampingkan".

Jika Anda membutuhkan nilai variabel untuk memuat baris baru, Anda harus menggunakan pernyataan "define" sebagai
ditampilkan (atau Anda dapat menetapkan nilai secara langsung di Perl). ("endef" dipilih untuk
kompatibilitas dengan GNU make. Anda juga dapat menggunakan "enddef".) Ini terutama berguna untuk
"urutan perintah kalengan", misalnya, sesuatu seperti ini:

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

Kemudian Anda dapat menggunakan variabel multi-baris ini dalam beberapa aturan, seperti ini:

%.o : %.c
$(KOMPILE_C_PROGRAM)

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

Perhatikan bahwa Anda sering dapat mencapai efek yang sama dengan menggunakan titik koma alih-alih baris baru,
karena Shell mengartikannya sebagai pembatas perintah juga. Sebagai contoh,

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

akan memiliki efek yang sama, kecuali titik koma memaksa Perl untuk meneruskannya ke shell,
daripada menjalankan perintah secara langsung dan lebih efisien. Anda juga harus meletakkan masing-masing
bawaan pada barisnya sendiri, artinya Anda harus beralih ke gema eksternal di
kasus titik koma.

Ada satu spesialisasi ketika memperluas dalam "define", yaitu "define X :=" atau pada a
variabel yang sudah ":=", "define X &=" dan "define X +=". Dalam hal ini
"$(Shell command ...)" atau bawaan "$(&command ...)" jangan mengubah baris baru menjadi
spasi.

Mengekspor variabel untuk subproses

ekspor VAR ...
ekspor VAR = nilai
menimpa ekspor VAR += nilai

Bentuk pertama menandai variabel yang diberikan untuk diekspor ke subproses, dengan nilai apa pun
variabel kemudian memiliki. Bentuk kedua, yang hanya berlaku untuk satu variabel, tambahan
memberikan nilai segera. Semua varian penugasan diperbolehkan.

berbagi variabel di seluruh makefile

VAR global...
VAR global = nilai
menimpa VAR global &= nilai

Bentuk pertama menandai variabel yang diberikan sebagai global untuk semua makefile. Jika salah satu dari mereka
sudah memiliki nilai, nilai itu dipindahkan dari variabel lokal makefile ke global
satu. Namun jika, pada saat pernyataan ini dilihat, makefile lain telah memiliki
nilai untuk salah satu dari mereka, maka makefile tersebut tidak akan melihat yang global.

Bentuk kedua, yang hanya berlaku untuk satu variabel, juga memberikan nilai yang tepat
jauh. Semua varian penugasan diperbolehkan. Perhatikan bahwa ":=" akan segera diperluas
ke nilai-nilai di makefile lokal. Sebaliknya "=" variabel akan diperluas ke
nilai pada titik penggunaan.

Variabel global bisa jadi sulit untuk ditangani, karena makepp dapat memuat makefile di mana saja
urutan, karena kebutuhan muncul untuk membangun beberapa target yang tidak ada aturan atau makefile yang dimuat.
Untuk alasan ini, disarankan untuk memiliki File RootMakepp dan untuk memuat semua secara eksplisit
orang lain yang memodifikasi atau menggunakan variabel dengan "load-makefile".

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

Perhatikan juga bahwa proyek Anda mungkin suatu hari nanti dibangun bersama dengan proyek lain. Untuk ini
alasan disarankan untuk selalu menjadikan nama proyek sebagai bagian dari nama variabel global apa pun.

Target khusus tugas

target: VARIABEL = string
target: VARIABEL := string
target: timpa VARIABEL += string

Menetapkan nilai spesifik target variabel. Nilai spesifik target sedang berlaku hanya
dalam suatu tindakan yang menghasilkan sasaran tertentu. Ini terutama digunakan untuk hal-hal seperti
ini:

CFLAG := -O2

my_prog: file1.o file2.o file_khusus.o

file_khusus.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

Apa yang terjadi di sini adalah bahwa semua file ".c" akan dikompilasi dengan optimasi ("-O2") kecuali
"special_file.c", yang dikompilasi dalam mode debug ("-g"). Ini adalah cara yang nyaman untuk
tentukan opsi kompilasi yang berbeda hanya untuk beberapa file.

Penetapan variabel khusus target seperti ini hanya berlaku untuk tindakan aturan; mereka
tidak berlaku saat mengevaluasi target atau dependensi aturan. Jika aturan
memiliki lebih dari satu target, penetapan variabel target-spesifik hanya diambil dari
pertama target. Perhatikan juga bahwa variabel spesifik target makepp sedikit berbeda
dari GNU make's karena mereka hanya berlaku untuk aturan untuk satu file yang disebutkan, dan tidak untuk
apapun pendahulunya.

Ekspansi wildcard dilakukan pada target, sehingga Anda dapat melakukan sesuatu seperti ini:

tes_*.o : CFLAGS += -DTEST

Untuk kompatibilitas dengan GNU make, "%" dapat digunakan sebagai pengganti "*".

Variabel Substitusi
Aturan substitusi variabel Makepp mirip dengan merek lain, tetapi agak
lebih bertenaga. Seperti pada semua merek, "$(CC)" atau "${CC}" keduanya mewakili nilai dari
variabel CC. Jika Anda membutuhkan tanda dolar literal, masukkan tanda dolar ganda ($$), seperti
ini:

sasaran: dep1 dep2 dep3 dep4
&rm -f $(keluaran)
untuk file di $(input); lakukan cat $$file >> $(output); selesai

Selain itu makepp memiliki sintaks "$[VARIABLE]", yang melakukan hal yang sama seperti yang lain
dua, tapi sebelum makepp groks apa pun. Ini memungkinkan menggunakannya untuk aturan lengkap
dan/atau bersyarat:

tentukan bracket_rule =
ifdef SOME_VAR
mengurung:
&echo ini adalah aturan -o $(output)
endif
pertahanan akhir

$[aturan_braket]

gaya rc substitusi

Secara default, makepp menggunakan substitusi rc-style (disebut demikian karena dipelopori oleh
kulit rc). Ini paling baik diilustrasikan dengan sebuah contoh:

MODUL = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(dependensi) -o $(target)

Awalan "module_dir/" ditambahkan ke setiap kata dalam MODUL, dan akhiran ".o" adalah
ditambahkan ke setiap kata.

Anda juga dapat menggunakan substitusi gaya rc tanpa memasukkan daftar kata ke dalam a
variabel; sintaksnya adalah "$( word1 word2)". Perhatikan spasi antara tanda kurung dan
kata pertama. Jadi contoh di atas bisa ditulis sebagai:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dependensi) -o $(target)

Sebuah variabel akan memberikan substitusi gaya rc hanya jika ada lebih dari satu kata di dalamnya.
Dengan satu kata itu seperti membuat tradisional. Sayangnya, ketika variabel kosong, ada
konflik. Tradisional membuat cukup memperluasnya ke string kosong. Tetapi ketika Anda memikirkan
itu sebagai daftar, Anda ingin "-I$(DIRLIST)" menghilang, bukan untuk memberikan "-I" yang kesepian. NS
solusinya adalah dengan membungkusnya ke dalam daftar yang dimulai dengan spasi: "-I$( $(DIRLIST))" memberi Anda
persis seperti banyak pilihan, karena ada kata-kata dalam daftar.

Jika Anda meletakkan beberapa variabel dalam kata yang sama yang diperluas ke susunan kata, gaya rc
substitusi sebenarnya mengambil produk kartesius, jadi Anda dapat melakukan sesuatu seperti ini jika
kamu ingin:

DIRS = s1 s2
MODUL = abc
SUFIKS = .o .c
FILE := $(DIRS)/$(MODULES)$(SUFFIXES)

dan FILES akan berisi string

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 spasi, substitusi gaya rc berhenti di kutipan apa pun, bulat, keriting, atau persegi apa pun
tanda kurung, dan salah satu dari ", : ; = # @". Perhatikan bahwa ini mungkin mengejutkan, dan sekali lagi perlu
daftar eksplisit. Katakanlah Anda ingin mencari header dengan wildcard di semua direktori
dimulai dengan huruf besar:

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

Jika substitusi gaya rc menghalangi, atau jika Anda perlu memimpin atau mengikuti
spasi putih di variabel make Anda, maka Anda dapat mematikan substitusi gaya rc dengan menyetel
variabel "makepp_simple_concatenation=1". Anda dapat mematikannya secara global dengan perintah
garis atau sebagai variabel lingkungan. Atau berdasarkan per-makefile dengan mengatur variabel di
file make Anda. Anda harus melakukan ini di dekat bagian atas makefile, atau Anda mungkin mengalami
situasi lucu di mana substitusi gaya rc digunakan untuk beberapa evaluasi dan bukan yang lain.
(Semua ekspresi yang dievaluasi sebelum penugasan akan menggunakan substitusi gaya rc, dan semua
ekspresi dievaluasi setelah tidak akan. Sejak saat evaluasi ekspresi di
makefiles rumit dan tidak selalu jelas dari urutan pernyataan di
makefile, yang terbaik adalah mengatur "makepp_simple_concatenation" sedini mungkin.) Anda bisa
bahkan atur hanya untuk satu target:

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

Karena "$[VARIABLE]" dievaluasi lebih awal dari "$(VARIABLE)", menggabungkan keduanya dalam rc-
substitusi tidak akan memberikan hasil yang Anda harapkan, kecuali jika Anda membungkusnya secara eksplisit
Daftar:

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

Substitusi Referensi

Referensi substitusi memiliki bentuk "$(VAR:A=B)", di mana A adalah pola yang cocok dan B adalah
pola untuk menggantikannya. Referensi substitusi adalah singkatan dari
fungsi "patsubst". Sebagai contoh:

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

akan mengatur "$(object_files)" menjadi "ao bo co do". "%" adalah kecocokan karakter khusus
string sembarang. Jika A dan B dimulai dengan "%", kasus umum saat mengganti
sufiks, mereka dapat dihilangkan:

file_objek = $(file_sumber:.c=.o)
object_files = $(source_files:c=o) # sama, karena . tidak istimewa

Ruang putih in variabel

Jika Anda perlu mengontrol spasi putih dalam sebuah variabel, Anda harus (saat ini) menonaktifkan rc-style
substitusi (dengan mengatur "makepp_simple_concatenation=1") dan kemudian gunakan sintaks seperti ini:

nol =
T = -o $(nol)

atau, dengan evaluasi kosong:

T = -o $()

Saat Anda melakukan ini, variabel "T" berisi "-o" diikuti dengan spasi.

Teknik seperti ini untuk menangani spasi tidak disarankan. Jika Anda membutuhkan variabel
di makefile Anda untuk memuat spasi, Anda harus berpikir serius tentang apa yang Anda lakukan.
Jika Anda perlu menangani spasi, biasanya jauh lebih baik untuk memasukkan kode Perl ke dalam . Anda
makefile untuk menanganinya (menggunakan pernyataan "perl_begin" atau "sub"), atau untuk menanganinya
dalam pernyataan shell dalam tindakan aturan.

Kasus-kasus ini biasanya muncul ketika orang mencoba menggunakan aturan yang sama untuk yang berbeda
arsitektur yang tidak menggunakan sintaks perintah Unix yang khas. Misalnya, terkadang seseorang melihat
hal-hal seperti ini di makefiles:

ifeq ($(ARCH),orang aneh)
HAI := / KELUARAN=
lain
nol :=
HAI := -o $(batal)
endif

%.o : %.c
$(KOMPILER) $(masukan) $(O)$(keluaran)

Anda dapat melakukan ini dengan makepp jika Anda benar-benar menginginkannya, tetapi Anda mungkin akan menemukan bahwa
makefiles jauh lebih mudah dibaca jika Anda memiliki variabel yang tidak terlalu rumit
substitusi, misalnya

ifeq ($(ARCH),orang aneh)
%.o : %.c
$(WEIRD_COMPILER) $(masukan) /OUTPUT=$(keluaran)
lain
%.o : %.c
$(CC) -c $(masukan) -o $(keluaran)
endif

Spasi tidak pernah diperbolehkan dalam nama variabel, hanya dalam nilainya. Ini berbeda
dari beberapa membuat implementasi.

secara otomatis Variabel
Variabel otomatis adalah variabel yang mengasumsikan nilai yang berbeda tergantung pada aturan yang mana
mereka dievaluasi. Makepp mendukung sebagian besar variabel otomatis yang lainnya
versi pakai. Selain itu, ia memiliki nama yang kurang samar dan lebih panjang untuk sebagian besar dari mereka
yang dapat Anda gunakan sebagai gantinya. (Untuk makefile lama yang mendefinisikan ulang nama-nama ini, the
definisi di makefile mengesampingkan arti default. Misalnya, jika Anda mengatakan
"target = abc" di makefile Anda, maka "$(target)" akan selalu diperluas ke "abc", dan tidak akan
lagi setara dengan $@.)

Berikut ini adalah daftar lengkap semua variabel otomatis yang didukung makepp:

keluaran
target
$@ Target dari aturan saat ini. Sebenarnya, karena makepp mendukung banyak target untuk
aturan apa pun, ini adalah pertama target. Misalnya, dalam aturan berikut

y.tab.c y.tab.h : parser.y
$(YACC) -o $(keluaran) $(YFLAGS) $(masukan)

"$(output)" akan berisi nilai y.tab.c. Karena variabel ajaib ini sebenarnya
fungsi, Anda juga dapat melewatkan indeks sebagai argumen. Ini dihitung dari 1 atau mundur
dari -1. Jadi "$(output 2)" atau "$(output -1)" akan berisi nilai y.tab.h.

Sementara ketiga bentuk variabel ini memiliki nilai yang sama, ada perbedaan dalam
interpretasi untuk aturan multitarget. Jika Anda menggunakan nama samar gaya lama $@,
makepp akan menafsirkan itu sebagai seperangkat aturan gaya lama, bukan aturan modern yang
menghasilkan semua target itu sekaligus:

ab: # benar-benar: masing-masing satu aturan untuk a dan b
sentuh $@

cd: # error: mpp mengeluh bahwa ini tidak membangun d
sentuh $(keluaran)

output
target
Semua target aturan saat ini. Sama seperti "$(target)" kecuali ada lebih dari satu
target. Dalam contoh di atas, "$(outputs)" akan menjadi y.tab.c y.tab.h. Anda dapat melewati
daftar indeks, jadi "$(outputs 2 1)" akan menjadi y.tab.h y.tab.c.

ketergantungan
memasukkan
$< Ketergantungan eksplisit pertama dari aturan. Misalnya, dalam aturan ini

%.o : %.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

"$(input)" akan menjadi nama dari .c file, terlepas dari apa .h file makepp
menemukan. Jika Anda menentukan lebih dari satu dependensi, Anda bisa mendapatkannya dengan melewatkan sebuah
indeks: "$(input $(INDEX))" adalah dependensi INDEX.

ketergantungan
input
$^ Semua dependensi eksplisit dari target, tidak termasuk .h file ditemukan oleh
makepp_scanning untuk menyertakan.

Misalnya, dalam aturan

prog.o : *.o
$(CC) $(CFLAGS) $(masukan) -o $(keluaran)

"$(inputs)" akan menjadi semua file .o di direktori. Anda dapat memilih hanya yang Anda
inginkan dengan melewatkan daftar indeks. Jika Anda secara eksplisit menentukan berbagai jenis file,
anda dapat memilihnya seperti pada "$(inputs 2 3 4)" (tetapi dengan wildcard ini tidak terlalu
menjanjikan).

diurutkan_dependensi
diurutkan_input
$+ Semua dependensi target, dalam urutan terurut, dengan duplikat dihapus.
Setara dengan "$(sort $(inputs))".

diubah_dependensi
berubah_input
$? Ketergantungan target yang telah berubah. Ini hanya mencakup eksplisit
dependensi (yaitu, yang Anda daftarkan di makefile), tidak ditemukan secara implisit
ketergantungan dari pemindaian (seperti file .h).

Ini biasanya digunakan dalam perintah seperti ini:

libmine.a : $(MODULES) : build_check abaikan_action
$(AR) dan $@ $?

yaitu, ar diperintahkan untuk mengganti hanya modul-modul yang telah berubah. (Perhatikan
aturan pemeriksaan build "ignore_action". Jika Anda tidak menentukan ini, makepp akan memaksa
tindakan yang akan dieksekusi setiap kali berubah. Jika tidak ada dependensi yang berubah,
string tindakan akan menjadi "ar ru libmine.a" yang mungkin berbeda dari sebelumnya
terakhir kali Anda menjalankannya, jadi tanpa "ignore_action" makepp akan menjalankannya. Di dalam
kasus, itu tidak berbahaya, tetapi dengan perintah lain, itu bisa menjadi masalah. Lihat
makepp_build_check untuk detail tentang "ignore_action".)

Membangun arsip seperti ini bukanlah ide yang baik karena akan membuat bangunan Anda kurang
dapat diandalkan. Masalahnya adalah jika Anda membuat arsip, maka hapus salah satu dari
modul dari daftar MODUL, modul akan tetap berada di arsip dan
makepp

batang
$* Batang dalam aturan pola (yaitu, apa pun yang cocok dengan '%'). Atau, jika ini
bukan aturan pola, mengembalikan nama file tanpa ekstensi (mis
setara dengan "$(nama dasar $(input))".

Ini sebagian besar untuk kompatibilitas mundur. Misalnya, dalam versi lama make the
satu-satunya cara untuk memberi tahu cara mengompilasi apa pun .c file ke yang sesuai .o file itu seperti
ini:

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

Ini adalah cara yang buruk untuk menulis aturan. Jauh lebih jelas menggunakan gaya GNU-make
aturan pola, seperti ini:

%.o : %.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

untuk setiap
Nama file saat ini dari klausa "foreach". klausa "foreach" jarang digunakan,
tetapi mereka adalah jenis aturan pola tujuan umum yang didukung oleh makepp. Untuk
contoh,

#
# Bangun file .c dengan semacam preprosesor khusus:
#
%.c : %.k
$(praprosesor) $(masukan) > $(keluaran)

#
# Kompilasi file .c menjadi file .o:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(masukan) -o $(keluaran)

#
# Bendera kompilasi alternatif khusus untuk file .c yang diturunkan
# dari file .k:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(masukan) -o $(keluaran)

Lihat dokumentasi pada klausa foreach dalam aturan untuk detail dan contoh lebih lanjut.

$/ Ini pada dasarnya adalah konstanta, baik "/", atau pada Windows asli "\". Anda membutuhkannya, jika
Anda ingin memulai program secara portabel, misalnya yang Anda buat di direktori saat ini:

keluaran saya:
.$/prog saya >$(keluaran)

Untuk nama file yang diteruskan sebagai argumen, itu tidak terlalu diperlukan karena Windows dapat menangani Unix
sintaks di sana.

pilihan Variabel
Anda dapat mengatur ini dengan semua cara yang dijelaskan di atas (kecuali jika dinyatakan lain) untuk memodifikasi
perilaku makepp. Secara default, semuanya tidak terdefinisi.

MAKEPP_DEBUG
Jika Anda mengekspor ini dengan nilai sebenarnya sebelum memanggil makepp, Anda mendapatkan lebih banyak debug
info. Ini adalah "RULE_SOURCE" file yang dibuat saat ini berlaku di bawah
makeppinfo, mppi dan detail tentang ekspansi variabel dan pencocokan aturan di bawah
makepplog, mppl. Ini juga akan menunjukkan kepada Anda jika makepp kehabisan memori atau hang,
karena itu tanpa henti memperluas variabel yang sama:

A = $A # evaluasi ditangguhkan, perlu :=
B = $C
C = $B

MAKEPP_LN_CP
Lihat catatan di bawah &ln.

makepp_percent_subdirs
Setel ini ke beberapa nilai sebenarnya (seperti 1) untuk memiliki "%" dalam target atau dependensi yang cocok
di lebih dari satu direktori.

makepp_require_phony
Setel ini ke beberapa nilai sebenarnya (seperti 1) untuk mencegah kepalsuan implisit (yaitu jika aturan
berhasil tanpa menghasilkan targetnya). Variabel ini harus benar secara default, untuk
mencegah rantai ketergantungan yang rusak, tetapi itu akan merusak kompatibilitas dengan
makefile yang ceroboh.

makepp_signature_C_flat
Ini adalah opsi untuk tanda tangan C. Setel ini ke beberapa nilai sebenarnya (seperti 1) untuk memperlakukan Anda
sumber sebagai diratakan, yaitu semua baris baru (kecuali di sekitar pernyataan praprosesor) adalah
diperlakukan seperti spasi putih dan arahan "#line" diabaikan.

makepp_simple_concatenation
Setel ini ke beberapa nilai sebenarnya (seperti 1) untuk mencegah "substitusi gaya rc".

PERL
Anda dapat mengatur ini ke perl yang tepat yang Anda gunakan untuk menjalankan skrip di makepp
suite, dan mengekspornya. Ini dapat membantu menjalankan sub-skrip dengan Perl yang sama. Ini adalah
sebagian besar berguna untuk test suite, instalasi dan untuk build rekursif.

VPATH
Menyetel variabel ini ke beberapa nilai secara implisit memanggil "vpath % value".

Sudah ditentukan sebelumnya Variabel
Makepp menetapkan beberapa variabel, yang dapat Anda timpa:

AR Default: "ar".

ARFLAG
Default: "rv".

AS Default: "sebagai".

CC Default: Yang pertama ditemukan di antara "gcc", "egcc", "pgcc", "c89" atau "cc", atau di Windows
tambahan "cl" atau "bcc32".

CFLAG
Default: Jika "$(CC)" adalah kompiler GNU "-g -Wall", jika itu adalah salah satu dari dua Windows
compiler apa-apa, yang lain "-g".

CURDIR
Direktori tempat Makefile saat ini berada.

CXX Default: Yang pertama ditemukan di antara "g++", "c++", "pg++", "cxx", "C""C" atau "aCC", atau di
Windows tambahan "cl" atau "bcc32".

BENDERA CXX
Default: Jika "$(CXX)" adalah kompiler GNU "-g -Wall", jika itu adalah salah satu dari dua Windows
compiler apa-apa, yang lain "-g".

F77 Default: Yang pertama ditemukan di antara "f77", "g77" atau "fort77".

FC Default: "$(F77)".

LD Default: "l".

LEX Default: Yang pertama ditemukan di antara "lex" atau "flex".

LIBTOOL
Default: "libtool".

MEMBUAT
Variabel ini memiliki dua nilai yang berbeda, tergantung ada tidaknya
"--tradisional-rekursif-membuat". Makepp mengenali kapan variabel ini digunakan dan
mematikan beberapa fitur, bahkan sebelum rekursi benar-benar terjadi. Ini bisa jadi
tidak diinginkan saat Anda secara bertahap menghilangkannya, jadi pertama-tama ubah panggilan menjadi a
makepp spesifik "$((MAKE))", yang tidak akan mematikan fitur. Anda tidak harus mengaturnya
karena itu merusak pekerjaan rekursi pintar kami.

MEMBUAT TUJUAN
Variabel ini disetel tetapi tidak digunakan oleh makepp. Anda dapat memintanya untuk melakukan sesuatu hanya jika
target tertentu diminta.

Default: Apa pun yang secara eksplisit menargetkan pengguna (atau permintaan rekursif) yang disediakan.
Kosong ketika secara implisit membangun target default.

ifneq $(filter target khusus, $(MAKECMDGOALS))
# target khusus adalah salah satu target eksplisit saat ini
lain ifeq $(MAKECMDGOALS)
# tidak ada target eksplisit
endif

MAKEFLAGS (diekspor)
Opsi standar yang membuat makepp dipanggil. Mereka yang memiliki satu huruf
bentuk digabungkan di awal tanpa awalan "-" (surga tahu mengapa gmake memilih
untuk menghilangkan "-").

MEMBUAT INFO
Default: "make info".

MAKEPPFLAGS (diekspor)
Ini disetel ke nilai yang sama dengan MAKEFLAGS, tetapi hanya jika variabel ini ada di
lingkungan makepp.

_MAKEPPFLAGS (diekspor)
Opsi khusus makepp diperlukan untuk kompatibilitas POSIX/gmake, yang dengannya makepp
telah dipanggil. Ini berada dalam variabel terpisah sehingga makefile lama tidak dapat rusak
kompatibilitas dengan menghapus MAKEFLAGS. Ini hanya diatur dengan
"--tradisional-rekursif-membuat".

MAKEPP_VERSION
Versi makepp yang Anda gunakan. Jika ini adalah versi beta, itu akan memiliki
tanda hubung diikuti oleh YYMMDD ditambah beberapa data internal lainnya. Anda dapat menggunakan ini untuk "ifdef"
untuk menyembunyikan konstruksi khusus makepp dari merek lain.

Default: Nilai yang sama ditampilkan oleh "makepp --version"

PWD Sebuah alias untuk "CURDIR".

RM Default: "rm -f". Ini dimaksudkan untuk Makefile lama. Untuk yang baru sebaiknya menggunakan
perintah bawaan & rm secara langsung. Jika Anda ingin menulis aturan bersih palsu, lihat
perintah "makeppclean -r" sebagai gantinya.

ROOT
Jalur relatif ke akar sistem build Anda, yaitu direktori lebih jauh di
yang Anda memiliki "RootMakeppfile(.mk)". Jika Anda tidak memilikinya, variabel ini adalah
kosong.

SHELL
Variabel ini hanya dihormati jika Anda "mengekspornya". Dalam hal ini adalah Shell
yang digunakan untuk menjalankan tindakan tidak bawaan dengan beberapa karakter khusus di dalamnya (polos
yang dieksekusi secara langsung). Di Windows Strawberry atau ActiveState Perl, jika Anda memiliki
Shell mirip Unix, Anda harus menyetel variabel SHELL Anda ke nilai yang diakhiri dengan "sh"
atau "sh.exe" sebelum memanggil makepp.

Default: Yang pertama ditemukan di antara "/usr/xpg4/bin/sh" (misalnya Solaris) atau "/sbin/xpg4/sh"
(misalnya Reliant Unix) atau "/ Bin / sh".

YACC
Default: Yang pertama ditemukan di antara "bison -y" atau "yacc".

Variabel dan Perl
Nilai variabel disimpan sebagai skalar Perl biasa, sehingga Anda dapat mengaksesnya langsung dari
Kode Perl jika Anda perlu melakukan manipulasi rumit dengannya; lihat makepp_extending
untuk rincian.

Mengakses variabel global dari Perl dicapai dengan mengawalinya dengan "Mpp::global"
kemasan. Sebenarnya variabel apa pun, belum ada di makefile saat ini, dan yang Anda
assign ke dalam paket ini sejak saat itu akan menjadi global, seolah-olah Anda baru saja mengeluarkan
pernyataan "global" untuk itu.

Namun akses langsung ini rawan kesalahan! Pengguna mungkin telah mengganti variabel-variabel ini
pada baris perintah atau melalui lingkungan. Beberapa makefile lain dimuat sebelum ini
seseorang mungkin telah membuat variabel global atau target spesifik. Dalam kasus ini Anda tidak akan
temukan nilai variabel, atau saat menetapkannya, mungkin mengambil propertinya
(setara dengan pengubah "override", kecuali untuk target spesifik.)

Dengan akses langsung, Anda juga melewati perluasan variabel-variabel ini, jika bertipe
"=" atau ";=". Variabel khusus seperti "$(CC)" dimulai sebagai fungsi, hingga menjadi
ditugaskan untuk. Jadi dalam banyak kasus Anda tidak akan melihat nilainya.

Untuk alasan ini lebih baik membiarkan makepp menentukan nilai yang benar. Anda dapat menggunakan
varian "makeperl", di mana variabel telah dievaluasi sebelum kode Perl mendapat
ditafsirkan:

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

Jika Anda memerlukan variabel dalam blok makefile perl, ini dicapai melalui variabel Perl
$makefile sebagai berikut:

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

Fungsi selalu memasukkan objek makefile sebagai argumen kedua $_[1]:

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

Perintah seharusnya dipanggil dalam tindakan aturan, di mana objek makefile berada
dapat diakses melalui "$Mpp::Subs::rule->{MAKEFILE}":

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

Gunakan makepp_variables online menggunakan layanan onworks.net