makepp_variables - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

makepp_variables -- ວິທີໃຊ້ຕົວແປໃນ makepp

ລາຍລະອຽດ

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
ARFLAGS,
AS, C: DC,
ທຸງ,
"changed_dependencies",
change_inputs,
CurdIR,
CXX,
CXXFLAGS, D: "ຄວາມເພິ່ງພາອາໄສ",
"ຄວາມເພິ່ງພາອາໄສ", F: F77,
FC,
"foreach", I: ການປ້ອນຂໍ້ມູນ,
ວັດຖຸດິບ, L: LD,
LEX,
LIBTOOL, M: ເຮັດ,
MAKECMDGOALS,
ເຄື່ອງແຕ່ງກາຍ,
ຂໍ້ມູນ,
MAKEPP_DEBUG,
ທຸງ,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdir",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "ຜົນຜະລິດ",
"ຜົນໄດ້ຮັບ", P: PERL,
PWD, R: RM,
ຮາກ, S: ແກະ,
"sorted_dependencies",
sorted_inputs,
"ລໍາ", T: ເປົ້າ​ຫມາຍ,
ເປົ້າ ໝາຍ, V: VPATH, Y: YACC

ປົກກະຕິແລ້ວ Makefiles ໃຊ້ຕົວແປໃນຫຼາຍບ່ອນ. ເຫດຜົນທີ່ສໍາຄັນອັນຫນຶ່ງສໍາລັບການນໍາໃຊ້
ຕົວແປແມ່ນເພື່ອໃຫ້ແນ່ໃຈວ່າຂໍ້ມູນຖືກບັນຈຸຢູ່ໃນສະຖານທີ່ດຽວໃນ makefile, ດັ່ງນັ້ນ
ວ່າຖ້າຫາກວ່າມັນມີການປ່ຽນແປງ, ບໍ່ມີອັນຕະລາຍຂອງທັງສອງສໍາເນົາຂອງຂໍ້ມູນຂ່າວສານໄດ້ຮັບການອອກຈາກ
ຊິ້ງຂໍ້ມູນ.

ຊື່ຕົວແປແມ່ນຕົວພິມນ້ອຍໃຫຍ່. ໃນທາງທິດສະດີ, ຊື່ຕົວແປສາມາດເຮັດດ້ວຍຫຼາຍ
ລັກສະນະຕ່າງໆ, ແຕ່ makepp ອາດຈະບໍ່ສາມາດຂູດມັນໄດ້ຖ້າທ່ານເຮັດຫຍັງນອກເຫນືອຈາກ
ຕົວອັກສອນທີ່ເປັນຕົວເລກ, "_", ແລະ "-".

ແຕ່ລະ makefile ມີຊຸດຕົວແປຂອງຕົນເອງ, ແລະກໍານົດຕົວແປໃນຫນຶ່ງ makefile ຈະ
ບໍ່ມີຜົນຕໍ່ມູນຄ່າຂອງມັນຢູ່ໃນ makefile ອື່ນໆ. ຖ້າທ່ານຕ້ອງການໃຫ້ຕົວແປທີ່ກໍານົດໄວ້ໃນ
makefiles ຫຼາຍ, ວິທີທີ່ດີທີ່ສຸດທີ່ຈະເຮັດມັນແມ່ນເພື່ອໃຫ້ແຕ່ລະຄົນມີຄໍານິຍາມທົ່ວໄປ
ໄຟລ໌ (ເບິ່ງຄໍາຖະແຫຼງທີ່ປະກອບມີ) ຫຼືໃຊ້ຕົວແປ "ທົ່ວໂລກ".

ການປ່ຽນແປງ ການມອບຫມາຍ
ຕົວແປສາມາດສົມມຸດມູນຄ່າໃນຫຼາຍວິທີທີ່ແຕກຕ່າງກັນ:

· ຕົວແປອາດຈະຖືກຕັ້ງຢູ່ໃນ makefile. ມີຫຼາຍວິທີທີ່ແຕກຕ່າງກັນທີ່ຈະເຮັດ
ນີ້; ເບິ່ງຂ້າງລຸ່ມນີ້.

· ຄ່າຂອງຕົວແປອາດຈະຖືກລະບຸໄວ້ໃນເສັ້ນຄຳສັ່ງ, ແບບນີ້:

makepp CFLAGS=-O2 my_program

ຖ້າມີຫຼາຍກວ່າຫນຶ່ງ makefile ຖືກໂຫລດ, ຕົວແປ CFLAGS ຈະຖືກເຜີຍແຜ່ໄປຫາທັງຫມົດຂອງ
makefiles. ຕົວແປທີ່ຕັ້ງຢູ່ໃນບັນທັດຄໍາສັ່ງອັດຕະໂນມັດ override ການຕັ້ງຄ່າໃດໆຂອງ
ຕົວແປໃນ makefiles ໃດ.

ຖ້າຕ້ອງການ, makefile ຈະຕ້ອງ override ການຕັ້ງຄ່າເສັ້ນຄໍາສັ່ງຢ່າງຊັດເຈນ.
ຄວາມຕັ້ງໃຈແມ່ນບໍ່ສົນໃຈສິ່ງທີ່ຜູ້ໃຊ້ຮ້ອງຂໍ, ແຕ່ແທນທີ່ຈະເປັນວິທີການດັດແປງມັນ.
ຕົວແກ້ໄຂ "override" ອາດຈະນໍາຫນ້າຄໍາຖະແຫຼງການມອບຫມາຍໃດໆ. ແຕ່ໃນກໍລະນີຂອງ
ຄໍາຖະແຫຼງການຄໍາສໍາຄັນ, ຄໍາສັ່ງແມ່ນສໍາຄັນ, ຊຶ່ງເປັນເຫດຜົນທີ່ວ່າຕົວແປ override ແມ່ນ
ສະ​ແດງ​ໃຫ້​ເຫັນ​ຢູ່​ຂ້າງ​ລຸ່ມ​ນີ້​ສະ​ເຫມີ​. ຕົວແກ້ໄຂ "override" ນຳໃຊ້ກັບວຽກໃດນຶ່ງທີ່ມັນເທົ່ານັ້ນ
ປະຈຸບັນ, ແລະບໍ່ມີອິດທິພົນຕໍ່ການມອບຫມາຍຕໍ່ມາກັບຕົວແປ.

· ຖ້າຕົວແປຖືກຕັ້ງໄວ້ໃນສະພາບແວດລ້ອມ, ມັນສາມາດອ້າງອີງເປັນຕົວແປ makepp.
ປົກກະຕິການມອບໝາຍໃຫ້ກັບຕົວແປພາຍໃນ makefile override ການຕັ້ງຄ່າຈາກ
ສະພາບແວດລ້ອມ, ແຕ່ທ່ານສາມາດປ່ຽນແປງໄດ້ໂດຍການໃຊ້ "-e" ຫຼື "--environment-overrides"
ຕົວເລືອກເສັ້ນທາງຄໍາສັ່ງ.

ຕົວແປຖືກມອບໝາຍດ້ວຍໜຶ່ງໃນຫຼາຍການສະແດງຜົນ, ເຊັ່ນນີ້

X = 1
ໂມດູນ := abcd
CC ?= gcc
CFLAGS += -ຝາ
ກໍານົດ VAR
var ແຖວ 1
var ແຖວ 2
enddef
ເສັ້ນທາງສົ່ງອອກ := $(PWD):$(PATH)
global MYPROJECT.INFO = ຂໍ້ມູນທີ່ຈະເຫັນໃນ makefiles ທັງໝົດ

ການນຳໜ້າ ແລະຖັດຈາກຊ່ອງຫວ່າງອ້ອມຄ່າຕ່າງໆຈະຖືກຖອດອອກສະເໝີ.

ຜູ້ປະຕິບັດການມອບຫມາຍທີ່ແຕກຕ່າງກັນມີຄວາມຫມາຍແຕກຕ່າງກັນ.

ງ່າຍດາຍ ການມອບຫມາຍ ຜູ້ປະກອບການ

=
VARIABLE = ຂໍ້ຄວາມ
override VARIABLE = ຂໍ້ຄວາມ

ນີ້​ແມ່ນ​ຄໍາ​ຖະ​ແຫຼງ​ການ​ມອບ​ຫມາຍ​ປົກ​ກະ​ຕິ​ທີ່​ການ​ປະ​ຕິ​ບັດ​ທັງ​ຫມົດ​ຂອງ​ການ​ສະ​ຫນັບ​ສະ​ຫນູນ​. ໄດ້
ການສະແດງອອກທາງດ້ານຂວາມືບໍ່ໄດ້ຖືກປະເມີນຈົນກ່ວາມູນຄ່າຂອງ "$(VARIABLE)" ແມ່ນ
ໃຊ້ຕົວຈິງຢູ່ບ່ອນໃດບ່ອນໜຶ່ງ. ດັ່ງນັ້ນ, ຖ້າທ່ານເຮັດດັ່ງຕໍ່ໄປນີ້:

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

ຫຼັງຈາກນັ້ນ, "$(Y)" ຕໍ່ມາໃນ makefile ຈະປະເມີນເປັນ "2".

ໂດຍທົ່ວໄປແລ້ວ, ທ່ານຕ້ອງການໃຊ້ ":=" (ເບິ່ງຂ້າງລຸ່ມນີ້) ແທນ "=" ເພາະວ່າມັນ
ສະຫນອງການປະເມີນຕົວແປທີ່ຄາດເດົາໄດ້ຫຼາຍຂຶ້ນ. ຢ່າງໃດກໍຕາມ, ມີເວລາທີ່ທ່ານຕ້ອງການ
ເພື່ອເລື່ອນການປະເມີນຕົວແປ. ນອກຈາກນັ້ນ, ຖ້າທ່ານກໍາລັງຂຽນ makefile ທີ່ຕ້ອງເປັນ
backwards-compatible with some version of make other than GNU make , ຫຼັງຈາກນັ້ນທ່ານບໍ່ມີ
ທາງເລືອກ: ທ່ານສາມາດໃຊ້ "=" ເທົ່ານັ້ນ.

:=
VARIABLE := expr
override VARIABLE := expr

ນີ້ແມ່ນຄືກັນກັບ "VARIABLE = expr" ຍົກເວັ້ນດ້ານຂວາມືຖືກປະເມີນ
ຄັ້ງດຽວແລະສໍາລັບທັງຫມົດໃນເວລາຂອງການມອບຫມາຍ. ດັ່ງນັ້ນຖ້າ

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

ຫຼັງຈາກນັ້ນ, "$(Y)" ຕໍ່ມາໃນ makefile ຈະປະເມີນເປັນ "1" ນັບຕັ້ງແຕ່ນັ້ນແມ່ນສິ່ງທີ່ "$(X)" ແມ່ນ.
ເມື່ອ "$(Y)" ຖືກກໍານົດ.

;=
VARIABLE ;= expr
override VARIABLE ;= expr

ນີ້ແມ່ນຄືກັນກັບ "VARIABLE := expr" ຍົກເວັ້ນດ້ານຂວາມືຖືກປະເມີນ
ພຽງແຕ່ໃນເວລາທີ່ການນໍາໃຊ້ຄັ້ງທໍາອິດແລະຫຼັງຈາກນັ້ນຈື່. ນີ້ແມ່ນເປັນປະໂຫຍດສໍາລັບລາຄາແພງ
ຄໍາສັ່ງ, ເຊິ່ງສະເຫມີສົ່ງຄືນຄ່າດຽວກັນ, ແຕ່ວ່າທ່ານບໍ່ຕ້ອງການທີ່ຈະປະຕິບັດໃນເວລາທີ່
ການ​ກໍ່​ສ້າງ​ເປົ້າ​ຫມາຍ​ທີ່​ບໍ່​ກ່ຽວ​ຂ້ອງ​:

VAR1 ;= $(ການຄຳນວນແພງຫຼາຍ)
VAR2 ;= $(ຄຳສັ່ງພາຍນອກຂອງແກະ)

ໃຫ້ສັງເກດວ່າ makefiles ເກົ່າມັກຈະໃຊ້ ":=" ທີ່ນີ້, ຢ່າງຫນ້ອຍເຮັດອັນນີ້ຄັ້ງດຽວ.
ແຕ່ກັບຜູ້ປະຕິບັດການນີ້, ທ່ານຍັງສາມາດເຮັດບໍ່ໄດ້, ຖ້າປະຈຸບັນທ່ານເຮັດບໍ່ໄດ້
ຕ້ອງການມູນຄ່າ. ສໍາລັບຄ່າທີ່ຄືກັນໃນຫຼາຍໄດເລກະທໍລີ, ທ່ານສາມາດເຮັດໄດ້
ເພີ່ມປະສິດທິພາບນີ້ຕື່ມອີກດ້ວຍ "ທົ່ວໂລກ", ປຶກສາຫາລືຂ້າງລຸ່ມນີ້.

ຢ່າງໃດກໍຕາມ, ນີ້ບໍ່ແມ່ນຈຸດປະສົງທີ່ສະຫລາດທີ່ຈະບັງຄັບໃຫ້ຄໍາສັ່ງຂອງການປະເມີນຜົນ. ຖ້າ ກ
ຕົວແປທີ່ກໍານົດເຊັ່ນນີ້ປະກອບມີຄ່າຂອງຕົວແປອື່ນ, ແລະຕົວແປອື່ນ
ມີມູນຄ່າສະເພາະເປົ້າຫມາຍ, ແລະການຂະຫຍາຍຕົວທໍາອິດແມ່ນສໍາລັບເປົ້າຫມາຍນັ້ນ, ຫຼັງຈາກນັ້ນ
ຄ່າສະເພາະເປົ້າໝາຍຈະຕິດຢູ່ກັບທຸກສະພາບການອື່ນໆເຊັ່ນກັນ. ນີ້ແມ່ນ bug ແລະ
ຫວັງວ່າຈະໄດ້ຮັບການແກ້ໄຂໃນອະນາຄົດ.

+=
VARIABLE += expr
override VARIABLE += expr

ຕື່ມຂໍ້ມູນໃສ່ສະຕຣິງກັບເນື້ອຫາກ່ອນໜ້າຂອງຕົວແປ, ແຍກດ້ວຍຊ່ອງຫວ່າງ. ຖ້າ
ຕົວແປໄດ້ຖືກມອບຫມາຍໃນເມື່ອກ່ອນດ້ວຍ ":=", ຫຼັງຈາກນັ້ນທາງດ້ານຂວາມືຈະຖືກປະເມີນ
ກ່ອນ​ທີ່​ຈະ​ເພີ່ມ​ເຕີມ​.

&=
VARIABLE &= expr
override VARIABLE &= expr

Prepends string ກັບເນື້ອໃນທີ່ຜ່ານມາຂອງຕົວແປ, ແຍກອອກໂດຍຊ່ອງ.
ຖ້າຕົວແປໄດ້ຖືກມອບຫມາຍໃນເມື່ອກ່ອນດ້ວຍ ":=", ຫຼັງຈາກນັ້ນ, ເບື້ອງຂວາແມ່ນ
ປະເມີນກ່ອນທີ່ຈະຕື່ມຂໍ້ມູນໃສ່.

ຕົວຢ່າງຫນຶ່ງວິທີການຮັບປະກັນວ່າ "CFLAGS", ອັນໃດກໍ່ຕາມທີ່ຜູ້ໃຊ້ອາດຈະໃສ່ໃນ,
ສະເຫມີເລີ່ມຕົ້ນດ້ວຍ "-Wall" ແມ່ນສອງແຖວນີ້:

CFLAGS = -O2 # ອາດຈະ overridden ໃນແຖວຄໍາສັ່ງ
override CFLAGS &= -Wall # prepended unconditionally

ໃນ makefiles ເກົ່າ, ປົກກະຕິແລ້ວທ່ານຕ້ອງເຮັດບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້, ເຊິ່ງມີຂ້າງ
ຜົນ​ກະ​ທົບ​ຂອງ​ການ​ບັງ​ຄັບ​ໃຫ້​ປະ​ເພດ ":=" ເພື່ອ​ປ້ອງ​ກັນ​ບໍ່​ໃຫ້​ການ recursion ບໍ່​ສິ້ນ​ສຸດ​:

ຕົວປ່ຽນໄດ້ := expr $(ປ່ຽນໄດ້)

?=
VARIABLE ?= expr
override VARIABLE ?= expr # ບໍ່ມີປະໂຫຍດ, ແຕ່ຖືກກົດໝາຍ

ກໍານົດຄ່າຂອງຕົວແປ, ແຕ່ວ່າພຽງແຕ່ຖ້າຕົວແປບໍ່ໄດ້ລະບຸໄວ້ກ່ອນຫນ້າ
makefile, ໃນເສັ້ນຄໍາສັ່ງ, ຫຼືໃນສະພາບແວດລ້ອມ. ການມອບຫມາຍຂ້າງເທິງນີ້ແມ່ນ
ເທົ່າກັບ

ifndef ສາມາດປ່ຽນໄດ້
VARIABLE = expr
ສິ້ນສຸດ

!=
VARIABLE != ຄຳສັ່ງ shell
override VARIABLE != ຄຳສັ່ງ shell

ແລ່ນຄຳສັ່ງ Shell ແລະກຳນົດຕົວແປໃຫ້ມີຜົນຜະລິດມາດຕະຖານຂອງຄຳສັ່ງ.
ນີ້​ແມ່ນ​ແທ້​ທຽບ​ເທົ່າ​ກັບ

ຕົວປ່ຽນໄດ້ := $(ຄຳສັ່ງແກະ)

ຫຼາຍແຖວ ຕົວແປ

ຄໍາຖະແຫຼງທີ່ "ກໍານົດ" ແມ່ນຫຼາຍເສັ້ນທຽບເທົ່າຂອງຄໍາຖະແຫຼງທີ່ງ່າຍດາຍຂ້າງເທິງ. ໄດ້
operator ຫຼັງຈາກຕົວແປແມ່ນທາງເລືອກ. ຖ້າຂາດຫາຍໄປ, ມັນເທົ່າກັບ "ກໍານົດຕົວແປ
=" . "&=" ແລະ "+=" ໂຕປະຕິບັດການແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍຢູ່ທີ່ນີ້, ໃນນັ້ນພວກມັນກາວໃສ່
ຄ່າເກົ່າກັບແຖວໃໝ່, ແທນທີ່ຈະເປັນຊ່ອງຫວ່າງ. ຈະຕ້ອງບໍ່ມີຫຍັງຍົກເວັ້ນ a
ຄໍາຄິດຄໍາເຫັນຫຼັງຈາກຄໍາຖະແຫຼງການ, ie ມູນຄ່າເລີ່ມຕົ້ນໃນແຖວຕໍ່ໄປ.

ກໍານົດຕົວແປ :=
ແຖວທຳອິດຂອງຄ່າຕົວແປ
ແຖວທີສອງຂອງຄ່າຂອງຕົວແປ
ແຖວທີສາມຂອງຄ່າຕົວແປ
ສິ້ນສຸດ

override ກໍານົດ VARIABLE
...
enddef

ຄໍາສໍາຄັນກ່ອນທີ່ຈະ "ກໍານົດ" ສາມາດເປັນການປະສົມປະສານຂອງ "ການສົ່ງອອກ" ຫຼື "ທົ່ວໂລກ" ແລະ
"ຍົກເລີກ".

ຖ້າທ່ານຕ້ອງການຄ່າຂອງຕົວແປເພື່ອໃຫ້ມີເສັ້ນໃຫມ່, ທ່ານຕ້ອງໃຊ້ຄໍາຖະແຫຼງທີ່ "ກໍານົດ" ເປັນ
ສະແດງໃຫ້ເຫັນ (ຫຼືທ່ານສາມາດກໍາຫນົດຄ່າໂດຍກົງໃນ Perl). ("endef" ຖືກເລືອກສໍາລັບ
ຄວາມເຂົ້າກັນໄດ້ກັບ GNU ເຮັດ. ທ່ານອາດຈະໃຊ້ "enddef".) ນີ້ແມ່ນປະໂຫຍດຕົ້ນຕໍສໍາລັບ
"ລໍາດັບຄໍາສັ່ງກະປ໋ອງ", ຕົວຢ່າງ, ບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້:

ກໍານົດ COMPILE_C_PROGRAM
@&echo "ການລວບລວມ $(input)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(ລວມທັງ) -c $(input) -o $(output)
ສິ້ນສຸດ

ຫຼັງຈາກນັ້ນ, ທ່ານສາມາດນໍາໃຊ້ຕົວແປຫຼາຍແຖວນີ້ໃນຫຼາຍກົດລະບຽບ, ເຊັ່ນນີ້:

%.o : %.c
$(COMPILE_C_PROGRAM)

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

ໃຫ້ສັງເກດວ່າທ່ານມັກຈະບັນລຸຜົນດຽວກັນໂດຍການໃຊ້ເຄື່ອງໝາຍຈຸດແທນເສັ້ນໃໝ່,
ເພາະວ່າ shell ຕີຄວາມໝາຍວ່າເປັນຕົວຂັ້ນຄຳສັ່ງຄືກັນ. ຍົກ​ຕົວ​ຢ່າງ,

COMPILE_C_PROGRAM = @echo "ການລວບລວມ $(input)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(ລວມທັງ) -c $(input) -o $(output)

ຈະມີຜົນຄືກັນ, ຍົກເວັ້ນວ່າ semicolon ບັງຄັບ Perl ຜ່ານມັນໄປຫາແກະ,
ແທນທີ່ຈະປະຕິບັດຄໍາສັ່ງໂດຍກົງແລະມີປະສິດທິພາບຫຼາຍຂຶ້ນ. ນອກນັ້ນທ່ານຍັງຕ້ອງໄດ້ໃສ່ແຕ່ລະຄົນ
buildin ຢູ່ໃນເສັ້ນຂອງຕົນເອງ, ຊຶ່ງຫມາຍຄວາມວ່າທ່ານຕ້ອງສະຫຼັບກັບ echo ພາຍນອກໃນ
ກໍລະນີ semicolon.

ມີຄວາມພິເສດຫນຶ່ງໃນເວລາທີ່ຂະຫຍາຍພາຍໃນ "define", ie "define X :=" ຫຼືກ່ຽວກັບ a
ຕົວແປທີ່ເຄີຍເປັນ ":=", "define X &=" ແລະ "define X +=". ໃນກໍລະນີດັ່ງກ່າວນີ້
"$(shell command ...)" ຫຼື buildin "$(&command ...)" ບໍ່ໄດ້ປ່ຽນສາຍໃໝ່ເປັນ.
ສະຖານທີ່.

ການສົ່ງອອກ ຕົວແປ to ຂະບວນການຍ່ອຍ

ສົ່ງອອກ VAR ...
VAR = ສົ່ງອອກ
ຍົກເລີກການສົ່ງອອກ VAR += ຄ່າ

ແບບຟອມທໍາອິດຫມາຍຕົວແປທີ່ໃຫ້ສໍາລັບການສົ່ງອອກໄປຍັງຂະບວນການຍ່ອຍ, ມີມູນຄ່າໃດກໍ່ຕາມ
ຕົວແປຫຼັງຈາກນັ້ນມີ. ຮູບແບບທີສອງ, ເຊິ່ງໃຊ້ກັບຕົວແປຫນຶ່ງເທົ່ານັ້ນ, ນອກຈາກນັ້ນ
ກຳນົດຄ່າທັນທີ. ການປ່ຽນແປງທັງໝົດຂອງການມອບໝາຍແມ່ນອະນຸຍາດ.

ການແບ່ງປັນ ຕົວແປ ໃນທົ່ວ makefiles

VAR ທົ່ວໂລກ...
global VAR = ຄ່າ
ລົບລ້າງ VAR ທົ່ວໂລກ &= ຄ່າ

ແບບຟອມທໍາອິດຫມາຍຕົວແປທີ່ໃຫ້ມາເປັນທົ່ວໂລກສໍາລັບ makefiles ທັງຫມົດ. ຖ້າ​ຫາກ​ວ່າ​ໃດໆ​ຂອງ​ເຂົາ​ເຈົ້າ​
ມີມູນຄ່າແລ້ວ, ຄ່ານັ້ນຖືກຍ້າຍຈາກຕົວແປທ້ອງຖິ່ນ makefile ໄປສູ່ທົ່ວໂລກ
ຫນຶ່ງ. ຢ່າງໃດກໍຕາມ, ໃນເວລາທີ່ຄໍາຖະແຫຼງການນີ້ແມ່ນເຫັນ, makefiles ອື່ນໆມີແລ້ວ
ມູນຄ່າສໍາລັບການໃດໆຂອງພວກເຂົາ, ຫຼັງຈາກນັ້ນ makefiles ເຫຼົ່ານັ້ນຈະບໍ່ເຫັນທົ່ວໂລກ.

ຮູບແບບທີສອງ, ເຊິ່ງໃຊ້ກັບຕົວແປອັນດຽວເທົ່ານັ້ນ, ນອກຈາກນັ້ນຍັງກໍານົດຄ່າທີ່ຖືກຕ້ອງ
ຫ່າງ. ການປ່ຽນແປງທັງໝົດຂອງການມອບໝາຍແມ່ນອະນຸຍາດ. ໃຫ້ສັງເກດວ່າ ":=" ຈະຂະຫຍາຍທັນທີ
ກັບຄ່າໃນ makefile ທ້ອງຖິ່ນ. ໃນທາງກົງກັນຂ້າມ "=" ຕົວແປຈະຂະຫຍາຍໄປຫາ
ຄຸນຄ່າຢູ່ໃນຈຸດຂອງການນໍາໃຊ້.

ຕົວແປທົ່ວໂລກສາມາດຈັດການກັບບັນຫາໄດ້ຍາກ, ເພາະວ່າ makepp ອາດຈະໂຫຼດ makefiles ໃນອັນໃດກໍ່ໄດ້
ຄໍາສັ່ງ, ຕາມຄວາມຕ້ອງການທີ່ເກີດຂື້ນໃນການກໍ່ສ້າງບາງເປົ້າຫມາຍທີ່ບໍ່ມີກົດລະບຽບຫຼື makefiles ຖືກໂຫລດ.
ສໍາລັບເຫດຜົນນີ້, ແນະນໍາໃຫ້ມີ a RootMakeppfile ແລະການໂຫຼດທັງໝົດຢ່າງຈະແຈ້ງ
ອື່ນໆທີ່ດັດແປງຫຼືໃຊ້ຕົວແປທີ່ມີ "load-makefile".

GLIBLIBS ທົ່ວໂລກ ;= $(shell pkg-config --libs glib-2.0)

ຈື່ໄວ້ອີກວ່າໂຄງການຂອງເຈົ້າອາດຈະຖືກສ້າງໃນມື້ໜຶ່ງຮ່ວມກັບໂຄງການອື່ນໆ. ສໍາລັບການນີ້
ເຫດຜົນມັນໄດ້ຖືກແນະນໍາໃຫ້ສະເຫມີເຮັດໃຫ້ຊື່ໂຄງການເປັນສ່ວນຫນຶ່ງຂອງຊື່ຕົວແປທົ່ວໂລກ.

ເປົ້າໝາຍສະເພາະ ວຽກມອບ ໝາຍ

target: VARIABLE = string
target: VARIABLE := string
target: override VARIABLE += string

ກໍານົດຄ່າເປົ້າຫມາຍສະເພາະຂອງຕົວແປ. ຄ່າສະເພາະເປົ້າໝາຍແມ່ນມີຜົນ ພຽງແຕ່
ໃນ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ຜະ​ລິດ​ໄດ້​ເປົ້າ​ຫມາຍ​ດັ່ງ​ກ່າວ​ໄດ້​. ນີ້ຖືກນໍາໃຊ້ຕົ້ນຕໍສໍາລັບສິ່ງຕ່າງໆເຊັ່ນ
ນີ້:

CFLAGS := -O2

my_prog: file1.o file2.o special_file.o

special_file.o : CFLAGS := -g

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

ສິ່ງທີ່ເກີດຂຶ້ນນີ້ແມ່ນວ່າໄຟລ໌ ".c" ທັງຫມົດຈະຖືກລວບລວມດ້ວຍການເພີ່ມປະສິດທິພາບ ("-O2") ຍົກເວັ້ນ
"special_file.c", ເຊິ່ງຖືກລວບລວມໃນຮູບແບບດີບັກ ("-g"). ນີ້ແມ່ນວິທີທີ່ສະດວກທີ່ຈະ
ລະບຸທາງເລືອກການລວບລວມທີ່ແຕກຕ່າງກັນສໍາລັບພຽງແຕ່ສອງສາມໄຟລ໌.

ການມອບໝາຍຕົວແປສະເພາະເປົ້າໝາຍແບບນີ້ນຳໃຊ້ກັບການປະຕິບັດຂອງກົດລະບຽບເທົ່ານັ້ນ; ເຂົາເຈົ້າ
ບໍ່ມີຜົນບັງຄັບໃຊ້ໃນເວລາທີ່ການປະເມີນເປົ້າຫມາຍຫຼືຄວາມຂຶ້ນກັບຂອງກົດລະບຽບ. ຖ້າ​ຫາກ​ວ່າ​ກົດ​ລະ​ບຽບ​
ມີຫຼາຍກວ່າຫນຶ່ງເປົ້າຫມາຍ, ການມອບຫມາຍຕົວແປສະເພາະເປົ້າຫມາຍແມ່ນປະຕິບັດພຽງແຕ່ຈາກ
ຄັ້ງທໍາອິດ ເປົ້າ​ຫມາຍ. ໃຫ້ສັງເກດວ່າຕົວແປເປົ້າຫມາຍສະເພາະຂອງ makepp ແມ່ນແຕກຕ່າງກັນເລັກນ້ອຍ
ຈາກ GNU ເຮັດໃຫ້ພວກເຂົາພຽງແຕ່ນໍາໃຊ້ກັບກົດລະບຽບສໍາລັບເອກະສານຫນຶ່ງທີ່ໄດ້ກ່າວມາ, ແລະບໍ່ແມ່ນ
ລຸ້ນກ່ອນໜ້າອັນໃດກໍໄດ້.

ການຂະຫຍາຍຕົວຂອງ Wildcard ແມ່ນປະຕິບັດຢູ່ໃນເປົ້າຫມາຍ, ດັ່ງນັ້ນທ່ານສາມາດເຮັດບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້:

test_*.o : CFLAGS += -DTEST

ສໍາລັບຄວາມເຂົ້າກັນໄດ້ກັບ GNU make, "%" ອາດຈະຖືກນໍາໃຊ້ແທນ "*".

ການປ່ຽນແປງ ປ່ຽນແທນ
ກົດລະບຽບການທົດແທນຕົວແປຂອງ Makepp ແມ່ນຄ້າຍຄືກັນກັບການຜະລິດອື່ນໆ, ແຕ່ບາງຢ່າງ
ມີອໍານາດຫຼາຍ. ດັ່ງທີ່ເຮັດທັງໝົດ, "$(CC)" ຫຼື "${CC}" ທັງສອງເປັນຕົວແທນຂອງມູນຄ່າ
CC ປ່ຽນແປງໄດ້. ຖ້າທ່ານຕ້ອງການສັນຍາລັກເງິນໂດລາ, ໃສ່ເຄື່ອງຫມາຍເງິນໂດລາສອງເທົ່າ ($$), ເຊັ່ນ
ນີ້:

ເປົ້າໝາຍ: dep1 dep2 dep3 dep4
&rm -f $(ຜົນຜະລິດ)
ສໍາລັບໄຟລ໌ໃນ $(ວັດສະດຸປ້ອນ); do cat $$file >> $(output); ສຳເລັດແລ້ວ

ນອກຈາກນັ້ນ makepp ມີ syntax "$[VARIABLE]", ເຊິ່ງເຮັດອັນດຽວກັນກັບອັນອື່ນ
ສອງ, ແຕ່ກ່ອນທີ່ຈະ makepp groks ຫຍັງອີກແດ່. ນີ້ອະນຸຍາດໃຫ້ໃຊ້ມັນສໍາລັບກົດລະບຽບທີ່ສົມບູນ
ແລະ/ຫຼືເງື່ອນໄຂ:

ກໍານົດ bracket_rule =
ifdef SOME_VAR
ວົງເລັບ:
&echo ນີ້ແມ່ນກົດລະບຽບ -o $(output)
ສິ້ນສຸດ
enddef

$[bracket_rule]

ແບບ rc ການທົດແທນ

ໂດຍຄ່າເລີ່ມຕົ້ນ, makepp ໃຊ້ການທົດແທນແບບ rc (ເອີ້ນວ່າເພາະວ່າມັນຖືກບຸກເບີກໂດຍ
rc shell). ນີ້ແມ່ນສະແດງໃຫ້ເຫັນດີທີ່ສຸດໂດຍຕົວຢ່າງ:

ໂມດູນ = abcd

mylib.a : module_dir/$(MODULES).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(ເປົ້າໝາຍ)

ຄຳນຳໜ້າ "module_dir/" ແມ່ນນຳໜ້າໃສ່ແຕ່ລະຄຳໃນ MODULES, ແລະຄຳຕໍ່ທ້າຍ ".o" ແມ່ນ
ຕື່ມໃສ່ກັບແຕ່ລະຄໍາ.

ທ່ານຍັງສາມາດໃຊ້ການທົດແທນແບບ rc ໂດຍບໍ່ຕ້ອງໃສ່ບັນຊີລາຍຊື່ຂອງຄໍາສັບຕ່າງໆເຂົ້າໄປໃນ a
ຕົວແປ; syntax ແມ່ນ "$ (word1 word2)". ໃຫ້ສັງເກດຊ່ອງຫວ່າງລະຫວ່າງວົງເລັບ ແລະ
ຄໍາທໍາອິດ. ດັ່ງນັ້ນຕົວຢ່າງຂ້າງເທິງສາມາດຖືກຂຽນເປັນ:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(dependencies) -o $(ເປົ້າໝາຍ)

ຕົວແປຈະໃຫ້ຕົວປ່ຽນແບບ rc ເທົ່ານັ້ນເມື່ອມີຫຼາຍກວ່າໜຶ່ງຄຳໃນນັ້ນ.
ດ້ວຍຄໍາດຽວມັນຄ້າຍຄືກັບການເຮັດແບບດັ້ງເດີມ. ອະນິຈາ, ເມື່ອຕົວແປຫວ່າງເປົ່າ, ມີ a
ຂໍ້ຂັດແຍ່ງ. ແບບດັ້ງເດີມເຮັດໃຫ້ພຽງແຕ່ຂະຫຍາຍມັນໄປຫາສາຍທີ່ຫວ່າງເປົ່າ. ແຕ່​ເມື່ອ​ຄິດ​ເຖິງ
ມັນເປັນບັນຊີລາຍຊື່, ທ່ານຕ້ອງການ "-I$ (DIRLIST)" ຫາຍໄປ, ບໍ່ໃຫ້ "-I". ໄດ້
ການ​ແກ້​ໄຂ​ແມ່ນ​ການ​ຫໍ່​ມັນ​ເຂົ້າ​ໄປ​ໃນ​ບັນ​ຊີ​ລາຍ​ການ​ທີ່​ເລີ່ມ​ຕົ້ນ​ດ້ວຍ​ຊ່ອງ​ຫວ່າງ​: "-I$($(DIRLIST))" ໃຫ້​ທ່ານ
ແນ່ນອນວ່າມີຫຼາຍທາງເລືອກ, ຍ້ອນວ່າມີຄໍາທີ່ຢູ່ໃນບັນຊີລາຍຊື່.

ຖ້າທ່ານໃສ່ຕົວແປຫຼາຍອັນໃນຄໍາດຽວກັນທີ່ຂະຫຍາຍໄປສູ່ array ຂອງຄໍາສັບ, rc-style
ການທົດແທນຕົວຈິງໃຊ້ເວລາຜະລິດຕະພັນ cartesian, ດັ່ງນັ້ນທ່ານສາມາດເຮັດບາງສິ່ງບາງຢ່າງເຊັ່ນນີ້ຖ້າຫາກວ່າ
ເຈົ້າ​ຕ້ອງ​ການ:

DIRS = s1 s2
ໂມດູນ = abc
SUFFIXES = .o .c
ໄຟລ໌ := $(DIRS)/$(MODULES)$(SUFFIXES)

ແລະ FILES ຈະມີສະຕຣິງ

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

ນອກຈາກພື້ນທີ່ສີຂາວ, ການທົດແທນແບບ rc ຈະຢຸດຢູ່ທີ່ວົງຢືມໃດໆ, ຮອບໃດ, curly ຫຼືສີ່ຫລ່ຽມ
ວົງເລັບ, ແລະອັນໃດນຶ່ງຂອງ ", : ; = # @". ໃຫ້ສັງເກດວ່ານີ້ອາດຈະແປກໃຈ, ແລະອີກເທື່ອຫນຶ່ງຕ້ອງການ
ບັນຊີລາຍຊື່ທີ່ຈະແຈ້ງ. ເວົ້າວ່າທ່ານຕ້ອງການຊອກຫາສ່ວນຫົວໂດຍ wildcard ໃນທຸກໄດເລກະທໍລີ
ເລີ່ມຕົ້ນດ້ວຍຕົວພິມໃຫຍ່:

BAD := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
ດີ := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

ຖ້າການທົດແທນແບບ rc ເຂົ້າໄປໃນທາງ, ຫຼືຖ້າທ່ານຕ້ອງການນໍາພາຫຼືຕິດຕາມ
ຊ່ອງຫວ່າງຢູ່ໃນຕົວແປຂອງທ່ານ, ຫຼັງຈາກນັ້ນທ່ານສາມາດປິດການທົດແທນແບບ rc ໂດຍການຕັ້ງຄ່າ
ຕົວແປ "makepp_simple_concatenation=1". ທ່ານສາມາດປິດມັນໄດ້ທົ່ວໂລກໃນຄໍາສັ່ງ
ເສັ້ນຫຼືເປັນຕົວແປສະພາບແວດລ້ອມ. ຫຼືບົນພື້ນຖານ per-makefile ໂດຍການຕັ້ງຄ່າຕົວແປໃນ
makefile ຂອງ​ທ່ານ​. ທ່ານຄວນເຮັດສິ່ງນີ້ຢູ່ໃກ້ກັບດ້ານເທິງຂອງ makefile, ຖ້າບໍ່ດັ່ງນັ້ນທ່ານອາດຈະແລ່ນເຂົ້າໄປໃນ
ສະຖານະການຕະຫລົກທີ່ການທົດແທນແບບ rc ຖືກນໍາໃຊ້ສໍາລັບການປະເມີນຜົນບາງຢ່າງແລະບໍ່ແມ່ນສິ່ງອື່ນໆ.
(ການສະແດງອອກທັງໝົດທີ່ຖືກປະເມີນກ່ອນການມອບໝາຍຈະໃຊ້ການທົດແທນແບບ rc, ແລະທັງໝົດ
ການສະແດງອອກທີ່ຖືກປະເມີນຫຼັງຈາກຈະບໍ່. ນັບຕັ້ງແຕ່ເວລາຂອງການປະເມີນຜົນຂອງການສະແດງອອກໃນ
makefiles ແມ່ນສັບສົນແລະບໍ່ຈະແຈ້ງສະ ເໝີ ໄປຈາກຄໍາສັ່ງຂອງຖະແຫຼງການໃນ
makefile, ມັນດີທີ່ສຸດທີ່ຈະຕັ້ງ "makepp_simple_concatenation" ໄວເທົ່າທີ່ຈະໄວໄດ້.) ເຈົ້າສາມາດ
ເຖິງແມ່ນຕັ້ງມັນໄວ້ພຽງເປົ້າໝາຍດຽວເທົ່ານັ້ນ:

ເປົ້າໝາຍ: makepp_simple_concatenation = 1
ເປົ້າ​ຫມາຍ:
&echo before_first$(LIST)after_last -o $(output)

ເນື່ອງຈາກວ່າ "$[VARIABLE]" ຖືກປະເມີນໄວກວ່າ "$(VARIABLE)", ສົມທົບສອງອັນໃນ rc-
ການທົດແທນຈະບໍ່ໃຫ້ຜົນໄດ້ຮັບທີ່ທ່ານອາດຈະຄາດຫວັງ, ເວັ້ນເສຍແຕ່ວ່າທ່ານຫໍ່ມັນຢ່າງຈະແຈ້ງ
ລາຍຊື່:

A = ab
N = 1 2
ບໍ່ດີ := $(A)$[N]
ດີ := $(A)$($[N])

ເສັ້ນສຸດທ້າຍໄດ້ຮັບການອ່ານເປັນ

BAD := $(A)1 2 # a1 b1 2
ດີ := $(A)$( 1 2) # a1 a2 b1 b2

ປ່ຽນແທນ ເອກະສານ

ການອ້າງອີງການທົດແທນມີຮູບແບບ "$(VAR:A=B)", ເຊິ່ງ A ແມ່ນຮູບແບບທີ່ກົງກັນ ແລະ B ແມ່ນ
ຮູບແບບເພື່ອທົດແທນມັນ. ການອ້າງອີງການທົດແທນແມ່ນຕົວຫຍໍ້ຂອງ
ຟັງຊັນ "patsubst". ຍົກ​ຕົວ​ຢ່າງ:

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

ຈະຕັ້ງ "$(object_files)" ເປັນ "ao bo co do". "%" ແມ່ນການຈັບຄູ່ຕົວອັກສອນພິເສດ
ສະຕິງທີ່ມັກ. ຖ້າທັງສອງ A ແລະ B ເລີ່ມຕົ້ນດ້ວຍ "%", ເປັນກໍລະນີທົ່ວໄປໃນເວລາທີ່ປ່ຽນແທນ
ຄໍາຕໍ່ທ້າຍ, ພວກເຂົາສາມາດຖືກຍົກເວັ້ນ:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # ອັນດຽວກັນ, ເພາະວ່າ . ບໍ່ແມ່ນພິເສດ

Whitespace in ຕົວແປ

ຖ້າທ່ານຕ້ອງການຄວບຄຸມພື້ນທີ່ຫວ່າງຢູ່ໃນຕົວແປ, ທ່ານຕ້ອງ (ປະຈຸບັນ) ປິດການໃຊ້ງານ rc-style
ການທົດແທນ (ໂດຍການຕັ້ງຄ່າ "makepp_simple_concatenation=1") ແລະຫຼັງຈາກນັ້ນໃຊ້ syntax ແບບນີ້:

null =
T = -o $(null)

ຫຼື, ດ້ວຍການປະເມີນຫວ່າງເປົ່າ:

T = -o $()

ເມື່ອທ່ານເຮັດສິ່ງນີ້, ຕົວແປ "T" ມີ "-o" ຕິດຕາມດ້ວຍຊ່ອງຫວ່າງ.

ເຕັກນິກປະເພດນີ້ເພື່ອຈັດການພື້ນທີ່ຂາວແມ່ນບໍ່ແນະນໍາ. ຖ້າທ່ານຕ້ອງການຕົວແປ
ໃນ makefile ຂອງທ່ານເພື່ອບັນຈຸຊ່ອງຫວ່າງ, ທ່ານຄວນຄິດຢ່າງຈິງຈັງກ່ຽວກັບສິ່ງທີ່ທ່ານກໍາລັງເຮັດ.
ຖ້າທ່ານຕ້ອງການຈັດການຊ່ອງຫວ່າງ, ມັນມັກຈະດີກວ່າທີ່ຈະໃສ່ລະຫັດ Perl ເຂົ້າໄປໃນຂອງທ່ານ
makefile ເພື່ອເບິ່ງແຍງມັນ (ໃຊ້ "perl_begin" ຫຼື "sub" ຖະແຫຼງການ), ຫຼືເພື່ອຈັດການກັບມັນ.
ໃນ​ຄໍາ​ຖະ​ແຫຼງ​ຂອງ shell ໃນ​ການ​ປະ​ຕິ​ບັດ​ຂອງ​ກົດ​ລະ​ບຽບ​.

ກໍລະນີເຫຼົ່ານີ້ມັກຈະເກີດຂຶ້ນໃນເວລາທີ່ປະຊາຊົນພະຍາຍາມໃຊ້ກົດລະບຽບດຽວກັນສໍາລັບການແຕກຕ່າງກັນ
ສະຖາປັດຕະຍະກໍາທີ່ບໍ່ໃຊ້ syntax ຄໍາສັ່ງ Unix ປົກກະຕິ. ຕົວຢ່າງ, ບາງຄັ້ງຄົນຫນຶ່ງເຫັນ
ສິ່ງຕ່າງໆເຊັ່ນນີ້ໃນ makefiles:

ifeq ($(ARCH), ອັດສະຈັນ)
O := /OUTPUT=
ອື່ນ
null :=
O := -o $(null)
ສິ້ນສຸດ

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

ເຈົ້າສາມາດເຮັດສິ່ງນີ້ກັບ makepp ຖ້າທ່ານຕ້ອງການແທ້ໆ, ແຕ່ເຈົ້າອາດຈະພົບວ່າຂອງເຈົ້າ
makefiles ແມ່ນສາມາດອ່ານໄດ້ຫຼາຍຖ້າທ່ານມີຕົວແປທີ່ສັບສົນຫນ້ອຍ
ການທົດແທນ, ຕົວຢ່າງ,

ifeq ($(ARCH), ອັດສະຈັນ)
%.o : %.c
$(WEIRD_COMPILER) $(input) /OUTPUT=$(output)
ອື່ນ
%.o : %.c
$(CC) -c $(input) -o $(output)
ສິ້ນສຸດ

Whitespace ບໍ່ເຄີຍຖືກອະນຸຍາດໃຫ້ຢູ່ໃນຊື່ຕົວແປ, ພຽງແຕ່ຢູ່ໃນຄ່າຂອງພວກມັນ. ນີ້ແມ່ນແຕກຕ່າງກັນ
ຈາກການຈັດຕັ້ງປະຕິບັດບາງອັນ.

ອັດຕະໂນມັດ Variables
ຕົວແປອັດຕະໂນມັດແມ່ນຕົວແປທີ່ສົມມຸດວ່າຄ່າທີ່ແຕກຕ່າງກັນຂຶ້ນກັບກົດລະບຽບໃດ
ເຂົາເຈົ້າໄດ້ຖືກປະເມີນໃນ. Makepp ສະຫນັບສະຫນູນຕົວແປອັດຕະໂນມັດສ່ວນໃຫຍ່ທີ່ອື່ນໆ
ສະ​ບັບ​ຂອງ​ການ​ນໍາ​ໃຊ້​. ນອກຈາກນັ້ນ, ມັນມີລະຫັດລັບຫນ້ອຍ, ຊື່ຍາວສໍາລັບພວກເຂົາສ່ວນໃຫຍ່
ທີ່ທ່ານສາມາດນໍາໃຊ້ແທນ. (ສໍາລັບ makefiles ມໍລະດົກທີ່ເກີດຂຶ້ນກັບ redefine ຊື່ເຫຼົ່ານີ້, ໄດ້
ຄໍານິຍາມໃນ makefile overrides ຄວາມຫມາຍເລີ່ມຕົ້ນ. ຕົວຢ່າງ, ຖ້າເຈົ້າເວົ້າ
"target = abc" ໃນ makefile ຂອງທ່ານ, ຫຼັງຈາກນັ້ນ "$(target)" ສະເຫມີຈະຂະຫຍາຍໄປ "abc", ແລະຈະບໍ່.
ຍາວເທົ່າກັບ $@.)

ຕໍ່ໄປນີ້ແມ່ນບັນຊີລາຍຊື່ເຕັມຂອງຕົວແປອັດຕະໂນມັດທັງຫມົດທີ່ makepp ສະຫນັບສະຫນູນ:

output
ເປົ້າ​ຫມາຍ
$@ ເປົ້າຫມາຍຂອງກົດລະບຽບໃນປະຈຸບັນ. ຕົວຈິງແລ້ວ, ນັບຕັ້ງແຕ່ makepp ສະຫນັບສະຫນູນເປົ້າຫມາຍຫຼາຍສໍາລັບ
ກົດລະບຽບໃດກໍ່ຕາມ, ນີ້ແມ່ນ ຄັ້ງທໍາອິດ ເປົ້າ​ຫມາຍ. ຕົວຢ່າງ, ໃນກົດລະບຽບຕໍ່ໄປນີ້

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

"$(output)" ຈະມີຄ່າ y.tab.c. ນັບຕັ້ງແຕ່ຕົວແປ magic ເຫຼົ່ານີ້ແມ່ນຢູ່ໃນຄວາມເປັນຈິງ
ຫນ້າທີ່, ທ່ານຍັງສາມາດຜ່ານດັດສະນີເປັນການໂຕ້ຖຽງ. ອັນນີ້ນັບຈາກ 1 ຫຼື ຖອຍຫຼັງ
ຈາກ -1. ດັ່ງນັ້ນ "$(output 2)" ຫຼື "$(output -1)" ຈະມີຄ່າ y.tab.h.

ໃນຂະນະທີ່ທັງສາມຮູບແບບຂອງຕົວແປນີ້ມີມູນຄ່າດຽວກັນ, ມີຄວາມແຕກຕ່າງກັນໃນ
ການຕີຄວາມໝາຍຂອງກົດລະບຽບຫຼາຍເປົ້າໝາຍ. ຖ້າທ່ານໃຊ້ຊື່ລະຫັດລັບແບບເກົ່າ $@,
makepp ຈະຕີຄວາມຫມາຍວ່າເປັນກົດລະບຽບແບບເກົ່າ, ແທນທີ່ຈະເປັນກົດລະບຽບທີ່ທັນສະໄຫມ
ຜະລິດເປົ້າຫມາຍເຫຼົ່ານັ້ນທັງຫມົດໃນຫນຶ່ງໄປ:

ab: # ແທ້ໆ: ກົດລະບຽບຫນຶ່ງສໍາລັບແຕ່ລະ a ແລະ b
ແຕະ $@

cd: # error: mpp ຈົ່ມວ່ານີ້ບໍ່ໄດ້ສ້າງ d
ແຕະ $(ອອກ)

ຜົນໄດ້ຮັບ
ເປົ້າຫມາຍ
ເປົ້າຫມາຍທັງຫມົດຂອງກົດລະບຽບໃນປະຈຸບັນ. ຄືກັນກັບ "$(ເປົ້າໝາຍ)" ເວັ້ນເສຍແຕ່ມີຫຼາຍກວ່າໜຶ່ງ
ເປົ້າ​ຫມາຍ. ໃນຕົວຢ່າງຂ້າງເທິງ, "$(outputs)" ຈະເປັນ y.tab.c y.tab.h. ເຈົ້າສາມາດຜ່ານໄດ້
ບັນຊີລາຍຊື່ດັດສະນີ, ດັ່ງນັ້ນ "$(outputs 2 1)" ຈະເປັນ y.tab.h y.tab.c.

ການເພິ່ງພາອາໄສ
ການປ້ອນຂໍ້ມູນ
$< ການຂຶ້ນກັບຢ່າງຈະແຈ້ງທຳອິດຂອງກົດລະບຽບ. ສໍາລັບຕົວຢ່າງ, ໃນກົດລະບຽບນີ້

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

"$(input)" ຈະເປັນຊື່ຂອງ .c ໄຟລ໌, ບໍ່ວ່າຈະເປັນອັນໃດ .h ໄຟລ໌ makepp
ຄົ້ນພົບ. ຖ້າເຈົ້າລະບຸການເພິ່ງພາອາໄສຫຼາຍກວ່າໜຶ່ງອັນ, ເຈົ້າສາມາດເອົາພວກມັນໄດ້ໂດຍການຖ່າຍທອດ
index: "$(input $(INDEX))" ແມ່ນ INDEXth dependency.

dependencies
ວັດສະດຸປ້ອນ
$^ ທັງໝົດການຂຶ້ນກັບຢ່າງຊັດເຈນຂອງເປົ້າໝາຍ, ບໍ່ລວມເອົາ .h ໄຟລ໌ທີ່ຄົ້ນພົບໂດຍ
makepp_scanning ປະກອບມີ.

ສໍາລັບຕົວຢ່າງ, ໃນກົດລະບຽບ

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

"$(inputs)" ຈະເປັນໄຟລ໌ .o ທັງໝົດໃນໄດເລກະທໍລີ. ເຈົ້າສາມາດເລືອກໄດ້ສະເພາະຕົວເຈົ້າເທົ່ານັ້ນ
ຕ້ອງການໂດຍການຜ່ານບັນຊີລາຍຊື່ດັດສະນີ. ຖ້າເຈົ້າລະບຸໄຟລ໌ປະເພດຕ່າງໆຢ່າງຈະແຈ້ງ,
ທ່ານ​ສາ​ມາດ​ເລືອກ​ເອົາ​ໃຫ້​ເຂົາ​ເຈົ້າ​ໃນ "$(inputs 2 3 4)" (ແຕ່​ວ່າ​ດ້ວຍ​ຕົວ​ແທນ​ທີ່​ນີ້​ບໍ່​ແມ່ນ​ເກີນ​ໄປ​.
ສັນຍາ).

sorted_dependencies
sorted_inputs
$+ ຄວາມເພິ່ງພາອາໄສທັງໝົດຂອງເປົ້າໝາຍ, ໃນການຈັດຮຽງຕາມລຳດັບ, ດ້ວຍການລຶບສິ່ງທີ່ຊ້ຳກັນອອກ.
ເທົ່າກັບ "$(sort $(inputs))".

change_dependencies
change_inputs
$? ຄວາມເພິ່ງພາອາໄສຂອງເປົ້າຫມາຍທີ່ມີການປ່ຽນແປງ. ນີ້ປະກອບມີພຽງແຕ່ຈະແຈ້ງ
ການເພິ່ງພາອາໄສ (ເຊັ່ນ, ອັນທີ່ທ່ານລະບຸໄວ້ໃນ makefile), ບໍ່ໄດ້ຄົ້ນພົບ implicitly
ການເພິ່ງພາອາໄສຈາກການສະແກນ (ເຊັ່ນ: ໄຟລ໌ .h).

ນີ້ແມ່ນໃຊ້ທົ່ວໄປໃນຄໍາສັ່ງເຊັ່ນນີ້:

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

ເຊັ່ນ, ar ຖືກບອກໃຫ້ປ່ຽນແທນພຽງແຕ່ໂມດູນທີ່ມີການປ່ຽນແປງ. (ຫມາຍເຫດ
"ignore_action" ສ້າງກົດລະບຽບການກວດສອບ. ຖ້າເຈົ້າບໍ່ລະບຸອັນນີ້, makepp ຈະບັງຄັບໃຫ້
ການປະຕິບັດທີ່ຈະຖືກປະຕິບັດທຸກຄັ້ງທີ່ມັນປ່ຽນແປງ. ຖ້າບໍ່ມີການເພິ່ງພາອາໃສມີການປ່ຽນແປງ, the
ສະຕິງການປະຕິບັດຈະເປັນ "ar ru libmine.a" ເຊິ່ງອາດຈະແຕກຕ່າງຈາກສິ່ງທີ່ມັນແມ່ນ
ຄັ້ງສຸດທ້າຍທີ່ທ່ານແລ່ນມັນ, ດັ່ງນັ້ນໂດຍບໍ່ມີການ "ignore_action" makepp ຈະປະຕິບັດມັນ. ໃນ​ນີ້
ກໍລະນີ, ມັນບໍ່ເປັນອັນຕະລາຍ, ແຕ່ກັບຄໍາສັ່ງອື່ນໆ, ມັນອາດຈະມີບັນຫາ. ເບິ່ງ
makepp_build_check ສໍາລັບລາຍລະອຽດກ່ຽວກັບ "ignore_action".)

ການສ້າງຄັງເກັບຂໍ້ມູນແບບນີ້ບໍ່ແມ່ນຄວາມຄິດທີ່ດີເພາະມັນຈະເຮັດໃຫ້ການກໍ່ສ້າງຂອງເຈົ້ານ້ອຍລົງ
ເຊື່ອຖືໄດ້. ບັນຫານີ້ແມ່ນວ່າຖ້າທ່ານສ້າງບ່ອນເກັບມ້ຽນ, ຫຼັງຈາກນັ້ນເອົາຫນຶ່ງຂອງ
ໂມດູນຈາກບັນຊີລາຍຊື່ຂອງ MODULES, ໂມດູນຈະຍັງຄົງຢູ່ໃນບ່ອນເກັບມ້ຽນແລະ
ແຕ່ງໜ້າ

ຕົ້ນກໍາເນີດ
$* ລຳຕົ້ນໃນກົດລະບຽບຮູບແບບ (ເຊັ່ນວ່າ '%' ກົງກັນອັນໃດກໍ່ຕາມ). ອີກທາງເລືອກ, ຖ້ານີ້
ບໍ່ແມ່ນກົດລະບຽບຮູບແບບ, ສົ່ງຄືນຊື່ໄຟລ໌ໂດຍບໍ່ມີການຂະຫຍາຍ (ie, ມັນເປັນ
ເທົ່າກັບ "$(basename $(input))".

ນີ້ແມ່ນສ່ວນໃຫຍ່ສໍາລັບການເຂົ້າກັນໄດ້ໃນດ້ານຫລັງ. ສໍາລັບຕົວຢ່າງ, ໃນສະບັບເກົ່າຂອງ make the
ວິທີດຽວທີ່ຈະບອກວິທີການລວບລວມຂໍ້ມູນໃດໆ .c ໄຟລ໌ເຂົ້າໄປໃນທີ່ສອດຄ້ອງກັນ .o ໄຟລ໌ແມ່ນຄ້າຍຄື
ນີ້:

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

ນີ້ແມ່ນວິທີທີ່ຂີ້ຕົວະທີ່ຈະຂຽນກົດລະບຽບ. ມັນຈະແຈ້ງກວ່າທີ່ຈະໃຊ້ແບບ GNU-make
ກົດ​ລະ​ບຽບ​ຮູບ​ແບບ​ນີ້​:

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

foreach
ຊື່ໄຟລ໌ປັດຈຸບັນຈາກປະໂຫຍກ "foreach". ປະໂຫຍກ "foreach" ແມ່ນບໍ່ຄ່ອຍໄດ້ໃຊ້,
ແຕ່ພວກມັນເປັນປະເພດທີ່ມີຈຸດປະສົງທົ່ວໄປທີ່ສຸດຂອງກົດລະບຽບຮູບແບບທີ່ makepp ສະຫນັບສະຫນູນ. ສໍາລັບ
ຍົກຕົວຢ່າງ,

#
# ສ້າງໄຟລ໌ .c ດ້ວຍເຄື່ອງປະມວນຜົນພິເສດບາງປະເພດ:
#
%.c : %.k
$(preprocessor) $(input) > $(output)

#
# ລວບລວມໄຟລ໌ .c ເປັນໄຟລ໌ .o:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

#
# ທຸງການຮວບຮວມແບບສະຫຼັບພິເສດສຳລັບໄຟລ໌ .c ທີ່ມາຈາກ
# ຈາກໄຟລ໌ .k:
#
$(foreach:%.k=%.o): $(foreach:%.k=%.c): foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(input) -o $(output)

ເບິ່ງເອກະສານກ່ຽວກັບ foreach clause ໃນກົດລະບຽບສໍາລັບລາຍລະອຽດເພີ່ມເຕີມແລະຕົວຢ່າງ.

$/ ອັນນີ້ແມ່ນຄ່າຄົງທີ່, ບໍ່ວ່າຈະເປັນ "/", ຫຼືຢູ່ໃນ Windows ເດີມ "\". ທ່ານຕ້ອງການມັນ, ຖ້າ
ທ່ານ​ຕ້ອງ​ການ​ທີ່​ຈະ​ເລີ່ມ​ຕົ້ນ​ໂຄງ​ການ portable​, ເຊັ່ນ​: ຫນຶ່ງ​ທີ່​ທ່ານ​ໄດ້​ສ້າງ​ຂຶ້ນ​ໃນ​ລະ​ບົບ​ປະ​ຈຸ​ບັນ​:

ຜົນຜະລິດຂອງຂ້ອຍ:
.$/myprog >$(ຜົນຜະລິດ)

ສໍາ​ລັບ​ຊື່​ໄຟລ​໌​ຜ່ານ​ເປັນ​ການ​ໂຕ້​ຖຽງ​ມັນ​ບໍ່​ຈໍາ​ເປັນ​ດັ່ງ​ນັ້ນ Windows ສາ​ມາດ​ຈັດ​ການ Unix​
syntax ຢູ່ທີ່ນັ້ນ.

ທາງເລືອກ Variables
ທ່ານສາມາດກໍານົດສິ່ງເຫຼົ່ານີ້ໃນທຸກວິທີທາງທີ່ອະທິບາຍຂ້າງເທິງ (ຍົກເວັ້ນຖ້າລະບຸໄວ້ເປັນຢ່າງອື່ນ) ເພື່ອດັດແປງ
bahaviour ຂອງ makepp. ໂດຍຄ່າເລີ່ມຕົ້ນພວກມັນແມ່ນບໍ່ໄດ້ກໍານົດທັງຫມົດ.

MAKEPP_DEBUG
ຖ້າທ່ານສົ່ງອອກອັນນີ້ດ້ວຍມູນຄ່າທີ່ແທ້ຈິງກ່ອນທີ່ຈະໂທຫາ makepp, ທ່ານຈະໄດ້ຮັບການແກ້ໄຂຫຼາຍຂຶ້ນ
ຂໍ້ມູນ. ນີ້ແມ່ນ "RULE_SOURCE" ຂອງໄຟລ໌ທີ່ສ້າງຂຶ້ນໃນຂະນະທີ່ອັນນີ້ມີຜົນກະທົບພາຍໃຕ້
makeppinfo, mppi ແລະລາຍລະອຽດກ່ຽວກັບການຂະຫຍາຍຕົວແປແລະກົດລະບຽບການຈັບຄູ່ພາຍໃຕ້
makepplog, mppl. ອັນນີ້ຍັງຈະສະແດງໃຫ້ທ່ານເຫັນຖ້າ makepp ໝົດຄວາມຊົງຈຳ ຫຼື hangs,
ເນື່ອງຈາກວ່າມັນແມ່ນການຂະຫຍາຍຕົວແປດຽວກັນທີ່ບໍ່ມີທີ່ສິ້ນສຸດ:

A = $A # ການປະເມີນຜົນການເລື່ອນເວລາ, ຕ້ອງການ :=
B = $C
C = $B

MAKEPP_LN_CP
ເບິ່ງບັນທຶກພາຍໃຕ້ &ln.

makepp_percent_subdir
ຕັ້ງຄ່ານີ້ເປັນຄ່າທີ່ແທ້ຈິງບາງຢ່າງ (ເຊັ່ນ: 1) ເພື່ອໃຫ້ມີ "%" ໃນເປົ້າໝາຍ ຫຼືການຂຶ້ນກັບການຈັບຄູ່
ໃນທົ່ວຫຼາຍກວ່າຫນຶ່ງໄດເລກະທໍລີ.

makepp_require_phony
ຕັ້ງຄ່ານີ້ເປັນຄ່າທີ່ແທ້ຈິງບາງຢ່າງ (ເຊັ່ນ: 1) ເພື່ອປ້ອງກັນຄວາມຫຼົງໄຫຼທີ່ບໍ່ຊັດເຈນ (ເຊັ່ນວ່າກົດລະບຽບ
ປະສົບຜົນສໍາເລັດໂດຍບໍ່ມີການຜະລິດເປົ້າຫມາຍຂອງມັນ). ຕົວແປນີ້ຄວນຈະເປັນຄວາມຈິງໂດຍຄ່າເລີ່ມຕົ້ນ, ເຖິງ
ປ້ອງກັນຕ່ອງໂສ້ການເພິ່ງພາອາໄສທີ່ແຕກຫັກ, ແຕ່ວ່າຈະທໍາລາຍຄວາມເຂົ້າກັນໄດ້ກັບຫຼັງ
makefiles sloppy.

makepp_signature_C_flat
ນີ້​ແມ່ນ​ທາງ​ເລືອກ​ທີ່​ຈະ​ລາຍ​ເຊັນ C. ຕັ້ງ​ຄ່າ​ນີ້​ເປັນ​ມູນ​ຄ່າ​ທີ່​ແທ້​ຈິງ​ຈໍາ​ນວນ​ຫນຶ່ງ (ເຊັ່ນ 1​) ເພື່ອ​ປິ່ນ​ປົວ​ຂອງ​ທ່ານ​
ແຫຼ່ງທີ່ເປັນແປ, ie ເສັ້ນໃຫມ່ທັງຫມົດ (ຍົກເວັ້ນປະມານ preprocessor ຖະແຫຼງການ) ແມ່ນ
ຖືກປະຕິບັດຄືກັບຊ່ອງຫວ່າງ ແລະຄຳສັ່ງ "#line" ແມ່ນຖືກລະເລີຍ.

makepp_simple_concatenation
ຕັ້ງຄ່ານີ້ເປັນຄ່າທີ່ແທ້ຈິງບາງຢ່າງ (ເຊັ່ນ: 1) ເພື່ອປ້ອງກັນ "ການທົດແທນແບບ rc".

ໄຂ່ມຸກ
ທ່ານສາມາດຕັ້ງຄ່ານີ້ເປັນ perl ທີ່ແນ່ນອນທີ່ທ່ານກໍາລັງໃຊ້ເພື່ອແລ່ນສະຄິບໃນ makepp
ຊຸດ, ແລະສົ່ງອອກມັນ. ນີ້ສາມາດຊ່ວຍໃຫ້ແລ່ນສະຄິບຍ່ອຍດ້ວຍ perl ດຽວກັນ. ນີ້​ແມ່ນ
ສ່ວນໃຫຍ່ແມ່ນເປັນປະໂຫຍດສໍາລັບຊຸດການທົດສອບ, ການຕິດຕັ້ງແລະສໍາລັບການກໍ່ສ້າງ recursive.

VPATH
ການຕັ້ງຄ່າຕົວແປນີ້ເປັນບາງຄ່າໂດຍ implicitly ເອີ້ນວ່າ "vpath % value".

ກຳ ນົດໄວ້ກ່ອນ Variables
Makepp ກຳນົດຕົວແປຈຳນວນໜຶ່ງໄວ້ລ່ວງໜ້າ, ເຊິ່ງທ່ານສາມາດລົບລ້າງໄດ້:

AR ມາດຕະຖານ: "ar".

ARFLAGS
ມາດຕະຖານ: "rv".

AS ມາດຕະຖານ: "ເປັນ".

CC ມາດຕະຖານ: ພົບຄັ້ງທໍາອິດໃນບັນດາ "gcc", "egcc", "pgcc", "c89" ຫຼື "cc", ຫຼືໃນ Windows
ນອກຈາກນັ້ນ, "cl" ຫຼື "bcc32".

ປ້າຍກຳກັບ
ມາດຕະຖານ: ຖ້າ "$(CC)" ເປັນ GNU compiler "-g -Wall", ຖ້າມັນເປັນຫນຶ່ງໃນສອງ Windows.
ລວບລວມບໍ່ມີຫຍັງ, ອື່ນ "-g".

CurdIR
ໄດເລກະທໍລີທີ່ Makefile ປະຈຸບັນຢູ່.

CXX ມາດຕະຖານ: ພົບຄັ້ງທໍາອິດໃນບັນດາ "g++", "c++", "pg++", "cxx", "C" "C" ຫຼື "aCC", ຫຼືຢູ່ໃນ
Windows ນອກຈາກນັ້ນ "cl" ຫຼື "bcc32".

CXXFLAGS
ມາດຕະຖານ: ຖ້າ "$(CXX)" ເປັນ GNU compiler "-g -Wall", ຖ້າມັນເປັນຫນຶ່ງໃນສອງ Windows.
ລວບລວມບໍ່ມີຫຍັງ, ອື່ນ "-g".

F77 ມາດຕະຖານ: ພົບຄັ້ງທໍາອິດໃນບັນດາ "f77", "g77" ຫຼື "fort77".

FC ມາດຕະຖານ: "$(F77)".

LD ມາດຕະຖານ: "ld".

lex ມາດຕະຖານ: ທໍາອິດທີ່ພົບເຫັນໃນບັນດາ "lex" ຫຼື "flex".

LIBTOOL
ມາດຕະຖານ: "libtool".

ເຮັດ
ຕົວແປນີ້ມີສອງຄ່າທີ່ແຕກຕ່າງກັນ, ຂຶ້ນກັບການມີຫຼືບໍ່ຂອງ
"--traditional-recursive-make". Makepp ຮັບຮູ້ເວລາທີ່ຕົວແປນີ້ຖືກນໍາໃຊ້ແລະ
ປິດຄຸນສົມບັດບາງຢ່າງ, ເຖິງແມ່ນວ່າກ່ອນທີ່ການເອີ້ນຄືນເກີດຂຶ້ນຈິງ. ນີ້ສາມາດເປັນ
undesirable ໃນຂະນະທີ່ທ່ານກໍາລັງຄ່ອຍໆກໍາຈັດມັນ, ສະນັ້ນທໍາອິດປ່ຽນການໂທເປັນ a
makepp ສະເພາະ "$((MAKE))" ເຊິ່ງຈະບໍ່ປິດຄຸນສົມບັດ. ທ່ານບໍ່ຄວນຕັ້ງມັນ
ເນື່ອງຈາກວ່າມັນທໍາລາຍ recursion smart ຂອງພວກເຮົາເຮັດວຽກປະມານ.

MAKECMDGOALS
ຕົວແປນີ້ຖືກຕັ້ງແຕ່ບໍ່ໄດ້ໃຊ້ໂດຍ makepp. ທ່ານສາມາດສອບຖາມມັນເພື່ອເຮັດບາງສິ່ງບາງຢ່າງພຽງແຕ່ຖ້າ
ເປົ້າໝາຍທີ່ແນ່ນອນໄດ້ຖືກຮ້ອງຂໍ.

ມາດຕະຖານ: ບໍ່ວ່າເປົ້າໝາຍອັນໃດທີ່ຊັດເຈນກັບຜູ້ໃຊ້ (ຫຼືການເອີ້ນຄືນ) ທີ່ສະໜອງໃຫ້.
ຫວ່າງເປົ່າເມື່ອສ້າງເປົ້າໝາຍເລີ່ມຕົ້ນໂດຍ implicitly.

ifneq $(ການກັ່ນຕອງພິເສດ-ເປົ້າໝາຍ, $(MAKECMDGOALS))
# ເປົ້າໝາຍພິເສດແມ່ນໜຶ່ງໃນເປົ້າໝາຍທີ່ຈະແຈ້ງໃນປະຈຸບັນ
ອື່ນ ifeq $(MAKECMDGOALS)
# ບໍ່ມີເປົ້າໝາຍທີ່ຊັດເຈນ
ສິ້ນສຸດ

MAKEFLAGS (ສົ່ງອອກແລ້ວ)
ທາງເລືອກມາດຕະຖານທີ່ makepp ຖືກເອີ້ນວ່າ. ຜູ້ທີ່ມີຈົດຫມາຍສະບັບດຽວ
ແບບຟອມແມ່ນລວມກັນໃນຕອນເລີ່ມຕົ້ນໂດຍບໍ່ມີ "-" ຊັ້ນນໍາ (ສະຫວັນຮູ້ວ່າເປັນຫຍັງ gmake ເລືອກ
ຖິ້ມ "-").

ສ້າງຂໍ້ມູນ
ມາດຕະຖານ: "ຂໍ້ມູນ".

MAKEPPFLAGS (ສົ່ງອອກແລ້ວ)
ອັນນີ້ຖືກຕັ້ງເປັນຄ່າດຽວກັນກັບ MAKEFLAGS, ແຕ່ວ່າພຽງແຕ່ຖ້າຕົວແປນີ້ຢູ່ໃນ
ສະພາບແວດລ້ອມຂອງ makepp.

_MAKEPPFLAGS (ສົ່ງອອກແລ້ວ)
ຕົວເລືອກສະເພາະຂອງ makepp ທີ່ຕ້ອງການສໍາລັບຄວາມເຂົ້າກັນໄດ້ຂອງ POSIX/gmake, ເຊິ່ງ makepp
ຖືກເອີ້ນ. ເຫຼົ່ານີ້ແມ່ນຢູ່ໃນຕົວແປແຍກຕ່າງຫາກດັ່ງນັ້ນ makefile ມໍລະດົກບໍ່ສາມາດທໍາລາຍໄດ້
ຄວາມເຂົ້າກັນໄດ້ໂດຍການຍົກເລີກການຕັ້ງຄ່າ MAKEFLAGS. ນີ້​ແມ່ນ​ກໍາ​ນົດ​ພຽງ​ແຕ່​ມີ​
"--traditional-recursive-make".

MAKEPP_VERSION
ສະບັບຂອງ makepp ທີ່ທ່ານກໍາລັງແລ່ນກັບ. ຖ້າມັນເປັນເວີຊັນເບຕ້າ, ມັນຈະມີ a
hyphen ຕິດຕາມດ້ວຍ YYMMDD ບວກກັບຂໍ້ມູນພາຍໃນເພີ່ມເຕີມ. ທ່ານສາມາດໃຊ້ນີ້ສໍາລັບ "ifdef"
ເພື່ອເຊື່ອງສິ່ງກໍ່ສ້າງສະເພາະຂອງ makepp ຈາກຜູ້ຜະລິດອື່ນໆ.

ມາດຕະຖານ: ຄ່າດຽວກັນສະແດງໂດຍ "makepp --version"

PWD ນາມແຝງສໍາລັບ "CURDIR".

RM ມາດຕະຖານ: "rm -f". ນີ້ແມ່ນຫມາຍຄວາມວ່າສໍາລັບ Makefiles ມໍລະດົກ. ສໍາລັບຄົນໃຫມ່ມັກໃຊ້
ຄໍາສັ່ງ builtin &rm ໂດຍກົງ. ຖ້າທ່ານຕ້ອງການຂຽນກົດລະບຽບສະອາດ phony, ເບິ່ງ
ຄໍາສັ່ງ "makeppclean -r" ແທນ.

ຮາກ
ເສັ້ນທາງພີ່ນ້ອງກັບຮາກຂອງລະບົບການກໍ່ສ້າງຂອງທ່ານ, ie ໄດເລກະທໍລີຕື່ມອີກໃນ
ເຊິ່ງທ່ານມີ "RootMakeppfile.mk)". ຖ້າທ່ານບໍ່ມີ, ຕົວແປນີ້ແມ່ນ
ຫວ່າງເປົ່າ

SHELL
ຕົວແປນີ້ຖືກເຄົາລົບພຽງແຕ່ຖ້າທ່ານ "ສົ່ງອອກ" ມັນ. ໃນກໍລະນີດັ່ງກ່າວມັນແມ່ນ Shell
ເຊິ່ງຖືກນໍາໃຊ້ເພື່ອປະຕິບັດການກະທໍາທີ່ບໍ່ໄດ້ສ້າງໂດຍມີລັກສະນະພິເສດບາງຢ່າງໃນມັນ (ທໍາມະດາ
ທີ່ຖືກປະຕິບັດໂດຍກົງ). ໃນ Windows Strawberry ຫຼື ActiveState Perl, ຖ້າທ່ານມີ
Shell ຄ້າຍຄື Unix, ທ່ານຕ້ອງຕັ້ງຕົວແປ SHELL ຂອງທ່ານເປັນຄ່າທີ່ລົງທ້າຍດ້ວຍ "sh" ແທນ.
ຫຼື "sh.exe" ກ່ອນທີ່ຈະ ໂທຫາ makepp.

ມາດຕະຖານ: ພົບຄັ້ງທໍາອິດໃນບັນດາ "/usr/xpg4/bin/sh" (ເຊັ່ນ: Solaris) ຫຼື "/sbin/xpg4/sh"
(ເຊັ່ນ: Reliant Unix) ຫຼື "/ ຖັງ / sh".

YACC
ມາດຕະຖານ: ທໍາອິດທີ່ພົບເຫັນໃນບັນດາ "bison -y" ຫຼື "yacc".

Variables ແລະ Perl
ຄ່າຕົວແປຖືກເກັບໄວ້ເປັນ Perl ປົກກະຕິ, ດັ່ງນັ້ນທ່ານສາມາດເຂົ້າເຖິງໄດ້ໂດຍກົງຈາກ
ລະຫັດ Perl ຖ້າທ່ານຈໍາເປັນຕ້ອງເຮັດການຫມູນໃຊ້ທີ່ສັບສົນກັບພວກເຂົາ; ເບິ່ງ makepp_extending
ສໍາລັບລາຍລະອຽດ.

ການເຂົ້າເຖິງຕົວແປທົ່ວໂລກຈາກ Perl ແມ່ນບັນລຸໄດ້ໂດຍການນຳໜ້າພວກມັນດ້ວຍ "Mpp::global"
ຊຸດ. ໃນຄວາມເປັນຈິງຕົວແປໃດໆ, ຍັງບໍ່ທັນມີຢູ່ໃນ makefile ໃນປັດຈຸບັນ, ແລະທີ່ທ່ານ
ມອບຫມາຍໃຫ້ຢູ່ໃນຊຸດນີ້ຈາກນັ້ນຈະເປັນທົ່ວໂລກ, ຄືກັບວ່າເຈົ້າຫາກໍ່ອອກ
ຖະແຫຼງການ "ທົ່ວໂລກ" ສໍາລັບມັນ.

ຢ່າງໃດກໍຕາມ, ການເຂົ້າເຖິງໂດຍກົງນີ້ແມ່ນຄວາມຜິດພາດ! ຜູ້ໃຊ້ອາດຈະ overridden ຕົວແປເຫຼົ່ານີ້
ໃນເສັ້ນຄໍາສັ່ງຫຼືຜ່ານສະພາບແວດລ້ອມ. ບາງ makefile ອື່ນໆ loaded ກ່ອນນີ້
ຫນຶ່ງອາດຈະເຮັດໃຫ້ຕົວແປທົ່ວໂລກຫຼືເປົ້າຫມາຍສະເພາະ. ໃນກໍລະນີດັ່ງກ່າວນີ້, ທ່ານຈະບໍ່
ຊອກຫາຄ່າຂອງຕົວແປ, ຫຼືໃນເວລາທີ່ກໍານົດມັນ, ອາດຈະເອົາຊັບສິນຂອງມັນໄປ
(ທຽບ​ເທົ່າ​ກັບ​ຕົວ​ປັບ​ປຸງ "override​"​, ຍົກ​ເວັ້ນ​ສໍາ​ລັບ​ການ​ສະ​ເພາະ​ເປົ້າ​ຫມາຍ​.)

ດ້ວຍການເຂົ້າເຖິງໂດຍກົງທ່ານຍັງຂ້າມການຂະຫຍາຍຕົວແປເຫຼົ່ານີ້, ຖ້າພວກເຂົາເປັນປະເພດ
"=" ຫຼື ";=". ຕົວແປພິເສດເຊັ່ນ "$(CC)" ເລີ່ມຕົ້ນເປັນຫນ້າທີ່, ຈົນກ່ວາພວກມັນເປັນ
ການ​ມອບ​ຫມາຍ​ໃຫ້. ດັ່ງນັ້ນ, ໃນຫຼາຍໆກໍລະນີ, ທ່ານຈະບໍ່ເຫັນຄຸນຄ່າຂອງມັນ.

ສໍາລັບເຫດຜົນເຫຼົ່ານີ້ມັນດີກວ່າທີ່ຈະໃຫ້ makepp ກໍານົດຄ່າທີ່ຖືກຕ້ອງ. ທ່ານສາມາດນໍາໃຊ້ໄດ້
ຕົວແປ "makeperl", ເຊິ່ງຕົວແປໄດ້ຖືກປະເມີນກ່ອນທີ່ລະຫັດ Perl ຈະໄດ້ຮັບ.
ແປວ່າ:

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

ຖ້າທ່ານຕ້ອງການຕົວແປໃນ makefile perl blocks ນີ້ແມ່ນບັນລຸໄດ້ໂດຍຜ່ານຕົວແປ Perl
$makefile ດັ່ງຕໍ່ໄປນີ້:

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

ຟັງຊັນສະເຫມີໄດ້ຮັບວັດຖຸ makefile ຜ່ານເປັນ argument ທີສອງ $_[1]:

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

ຄໍາສັ່ງແມ່ນຄວນຈະຖືກເອີ້ນພາຍໃນການປະຕິບັດກົດລະບຽບ, ບ່ອນທີ່ວັດຖຸ makefile ແມ່ນ
ເຂົ້າເຖິງໄດ້ຜ່ານ "$Mpp::Subs::rule->{MAKEFILE}":

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

ໃຊ້ makepp_variables ອອນລາຍໂດຍໃຊ້ບໍລິການ onworks.net