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

ໂຄງການ:

NAME

makepp_rules -- ວິທີບອກ makepp ສ້າງບາງສິ່ງບາງຢ່າງ

ລາຍລະອຽດ

?: &,
-,
@, B: :build_cache,
:build_check, D: :ສົ່ງ, E: :env, I: "ignore_error",
: ລວມ​ທັງ​, L: :ໂອ​ກາດ​ສຸດ​ທ້າຍ, M: ຜູ້ຜະລິດ, N: "ໂນໂກ້", P: :parser,
"perl", S: :ລາຍເຊັນ

ກົດລະບຽບແມ່ນສິ່ງທີ່ບອກ makepp ວິທີການສ້າງໄຟລ໌ຫຼືປະເພດໄຟລ໌. Makepp ສະຫນັບສະຫນູນ
syntax ກົດລະບຽບດຽວກັນກັບການປະຕິບັດອື່ນໆຂອງ make, ບວກກັບບາງສ່ວນເພີ່ມເຕີມຂອງຕົນເອງ.

ກົດລະບຽບມີຮູບແບບທົ່ວໄປ

target_expression : dependency_expression [ : arguments ທາງ​ເລືອກ​]
ຫຸ້ນ

ລາຍຊື່ເປົ້າໝາຍອາດບໍ່ມີຕົວແປອັດຕະໂນມັດ (ຍົກເວັ້ນ "$(foreach)"). ໄດ້
ບັນຊີລາຍຊື່ການເພິ່ງພາອາໄສອາດຈະມີພຽງແຕ່ຕົວແປອັດຕະໂນມັດທີ່ອ້າງອີງໃສ່ເປົ້າຫມາຍ (ເຊັ່ນ,
"$(output)", "$(outputs)", ຫຼືຄໍາສັບຄ້າຍຄືກັນ). ຄຳສັ່ງອາດມີອັດຕະໂນມັດໃດໆ
ຕົວແປ

ຖ້າ makepp ຕັດສິນໃຈວ່າກົດລະບຽບຕ້ອງໄດ້ຮັບການປະຕິບັດ, ແຕ່ລະເສັ້ນຂອງກົດລະບຽບຈະຖືກປະຕິບັດ
ຕາມລໍາດັບ, ແລະຖ້າອັນໃດສົ່ງຄືນສະຖານະທີ່ບໍ່ແມ່ນສູນ, ສ່ວນທີ່ເຫລືອຈະບໍ່ຖືກປະຕິບັດ (ແລະ.
makepp ເອົາລູກອອກດ້ວຍຄວາມຜິດພາດເວັ້ນເສຍແຕ່ວ່າທ່ານໄດ້ລະບຸທາງເລືອກ "-k" ໃນແຖວຄໍາສັ່ງ.)
ແຕ່ລະການກະ ທຳ ຄວນເປັນເສັ້ນດຽວເທົ່ານັ້ນ. ຖ້າການກະ ທຳ ຍາວເກີນໄປທີ່ຈະຂຽນໄດ້ງ່າຍໃນ a
ເສັ້ນດຽວ, ທ່ານສາມາດແບ່ງອອກເປັນຫຼາຍເສັ້ນແລະໃສ່ backslash ເພື່ອຊີ້ບອກວ່າ
ຫຼາຍສາຍຄວນຖືກລວມເຂົ້າເປັນອັນດຽວ.

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

· ເສັ້ນປະຕິບັດທຳອິດຕ້ອງຖືກຫຍໍ້ໜ້າຫຼາຍກວ່າເສັ້ນທີ່ມີເປົ້າໝາຍ.

· ຖ້າແຖວຖືກຫຍໍ້ໜ້າດ້ວຍຕົວອັກສອນແຖບໜຶ່ງ ຫຼື 8 ຍະຫວ່າງ ຫຼືຫຼາຍກວ່ານັ້ນ, ມັນຈະຖືກພິຈາລະນາ
ເສັ້ນປະຕິບັດ.

· ແຖວຫວ່າງເປົ່າ ຫຼື ແຖວຄຳເຫັນທີ່ມີຕົວອັກສອນ "#" ຢູ່ຂອບຂວາຈະສິ້ນສຸດ
ກົດ​ລະ​ບຽບ, ເວັ້ນ​ເສຍ​ແຕ່​ແຖວ​ຕໍ່​ໄປ​ທີ່​ບໍ່​ແມ່ນ​ເປົ່າ​ຫວ່າງ indented ຫຼາຍ​ກ​່​ວາ 8 ຊ່ອງ (ຫຼື​ຫຼາຍ​ກວ່າ​ຫນຶ່ງ​
ແຖບ).

· ຖ້າເສັ້ນຖືກຫຍໍ້ໜ້າຫຼາຍ ຫຼືຫຼາຍກວ່າເສັ້ນປະຕິບັດທຳອິດ, ມັນກໍ່ແມ່ນ
ພິຈາລະນາສາຍການປະຕິບັດເພີ່ມເຕີມ.

ມີບາງລາຍການປະຕິບັດພິເສດ:

& ສັນ​ຍາ​ລັກ​ນີ້​ຈະ​ຖືກ​ປະ​ຕິ​ບັດ​ຕາມ​ດ້ວຍ​ຊື່​ຄໍາ​ສັ່ງ​ແລະ​ຈໍາ​ນວນ​ຂອງ​ການ​ໂຕ້​ຖຽງ​ໃດ​ຫນຶ່ງ​. ແກະ
syntax ແມ່ນບໍ່ເຂົ້າໃຈຢ່າງສົມບູນຢູ່ທີ່ນີ້, ພຽງແຕ່ຄໍາເວົ້າດຽວແລະຄູ່ແລະ backslashed
ຕົວອັກສອນພາຍໃນ, ເຊັ່ນດຽວກັນກັບ makepp. ຊື່ຄໍາສັ່ງອາດຈະນໍາໄປສູ່ຫນ້າທີ່
"c_ຊື່" ຈະຖືກເອີ້ນດ້ວຍສາຍທີ່ຍັງເຫຼືອເປັນ arguments. ຖ້າຫາກວ່າຫນ້າທີ່ດັ່ງກ່າວສາມາດ
ບໍ່ພົບ, ນີ້ແມ່ນຄືກັນກັບການໂທຫາ "ແລ່ນ" ຈາກ "perl".

ນີ້ອະນຸຍາດໃຫ້ໂທຫາຢ່າງມີປະສິດທິພາບໃນຕົວ, makefile-provided ຫຼືຄໍາສັ່ງພາຍນອກ.
ຄໍານໍາຫນ້າ "&" ໄດ້ຖືກເລືອກເພາະວ່າມັນເປັນຫນ້າທີ່ invoker ໃນ Perl, ແລະເນື່ອງຈາກວ່າ
ໃນຕອນເລີ່ມຕົ້ນມັນຜິດກົດຫມາຍໃນ Shell.

$(ROOT)/include/%.h: %.h
&ln $(input) $(output)

ໂນໂຄ
@ ໂດຍປົກກະຕິ, ແຕ່ລະຄໍາສັ່ງຂອງ shell ຈະຖືກພິມອອກຍ້ອນວ່າມັນຖືກປະຕິບັດ. ຢ່າງໃດກໍຕາມ, ຖ້າຄໍາທໍາອິດ
ຂອງການປະຕິບັດແມ່ນ "noecho" (ຫຼືຖ້າມັນເລີ່ມຕົ້ນດ້ວຍຕົວອັກສອນ "@"), ຫຼັງຈາກນັ້ນຄໍາສັ່ງ
ບໍ່ໄດ້ພິມ. ຍົກ​ຕົວ​ຢ່າງ,

%.o: %.cxx
noecho $(LIBTOOL) --mode=compile $(CC) -c $(input)

ນີ້ຫມາຍຄວາມວ່າເມື່ອຄໍາສັ່ງ libtool ຖືກປະຕິບັດ, ມັນບໍ່ໄດ້ຖືກພິມອອກ. (Libtool
ຕົວຂອງມັນເອງປົກກະຕິແລ້ວພິມຄໍາສັ່ງດັດແກ້ທີ່ມັນປະຕິບັດ, ສະນັ້ນມັນຊໍ້າຊ້ອນກັບ
ພິມ​ມັນ​ສອງ​ຄັ້ງ​.)

ignore_error
- ໂດຍປົກກະຕິ, ຖ້າຄໍາສັ່ງ shell ສົ່ງຄືນສະຖານະທີ່ບໍ່ແມ່ນສູນ, ຫຼັງຈາກນັ້ນ makepp ຍົກເລີກເພາະວ່າ
ຄໍາສັ່ງລົ້ມເຫລວ. ຢ່າງ​ໃດ​ກໍ​ຕາມ​, ບາງ​ໂຄງ​ການ​ທີ່​ບໍ່​ຖືກ​ຕ້ອງ​ຕັ້ງ​ສະ​ຖາ​ນະ​ການ​ອອກ​, ຫຼື​
ອາດມີຂໍ້ຜິດພາດທີ່ບໍ່ເປັນອັນຕະລາຍ ແລະບໍ່ຄວນເອົາລູກອອກທັງໝົດ
ການລວບລວມ. ທ່ານສາມາດເຮັດໃຫ້ makepp ບໍ່ສົນໃຈສະຖານະການກັບຄືນໂດຍການລະບຸ
"ignore_error" ເປັນຄໍາທໍາອິດຂອງເສັ້ນຄໍາສັ່ງ (ຫຼື "-" ເປັນຕົວອັກສອນທໍາອິດ).
ຍົກ​ຕົວ​ຢ່າງ,

$(ການແຜ່ກະຈາຍສຽງ):
ignore_error rm -r my_program-$(VERSION) # ກໍາຈັດຂີ້ເຫຍື້ອທີ່ຜ່ານມາ.
&mkdir my_program-$(VERSION)
&cp $(FILES) my_program-$(VERSION)
tar cf my_program-$(VERSION).tar my_program-$(VERSION)

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

perl
ຜູ້ຜະລິດ
ນີ້ເປັນສິ່ງຈໍາເປັນຄືກັນກັບຄໍາຖະແຫຼງການ perl, ແຕ່ມັນຖືກປະຕິບັດໃນແຕ່ລະເວລາທີ່
ແລ່ນກົດລະບຽບ, ບໍ່ແມ່ນໃນເວລາອ່ານ makefile. ຕົວແປທໍາອິດແມ່ນ Perl ທໍາມະດາ
ລະຫັດ, ໃນຂະນະທີ່ຕົວແປທີສອງທໍາອິດຜ່ານຄໍາຖະແຫຼງໂດຍຜ່ານຕົວແປແບບ Make-style
ການຂະຫຍາຍຕົວ.

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

ຕາມກົດລະບຽບ, ຖະແຫຼງການ Perl ປະຈຸບັນຖືກປະເມີນຢູ່ໃນຂະບວນການຍ່ອຍທົ່ວໄປ, ຍົກເວັ້ນ
Windows. ນັ້ນຫມາຍຄວາມວ່າພວກເຂົາມີພຽງແຕ່ການອ່ານການເຂົ້າເຖິງຕົວແປ makefile ໃດໆ. ມັນຍັງເປັນ
ຂະບວນການທີ່ປະຕິບັດການກະທໍາທີ່ບໍ່ແມ່ນ Perl. ສະນັ້ນການໂທຫາ exec ຫຼື exit ຈະສັບສົນ
ແຕ່ງໜ້າ. ແຕ່ນີ້ອາດຈະມີການປ່ຽນແປງໃນອະນາຄົດ. ສໍາລັບວິທີການທີ່ມີປະສິດທິພາບໃນການໂທຫາ Perl
scripts, ເບິ່ງລາຍການທີ່ຜ່ານມາ "&" ຫຼື "ແລ່ນ".

$(ສະບັບພາສາ phony):
noecho perl {{ # $(ເປົ້າໝາຍ) & $(VERSION) ຈາກ Perl:
ພິມ "ນີ້ແມ່ນ ".f_target()." $VERSION\n";
}}
echo ທ່ານສາມາດປະສົມນີ້ກັບຄໍາສັ່ງ Shell
-makeperl { ພິມ "ນີ້ແມ່ນ $(ເປົ້າໝາຍ) $(VERSION)\n" }

ມີຫຼາຍປະເພດທີ່ແຕກຕ່າງກັນຂອງກົດລະບຽບ, ແຕ່ລະຄົນມີຈຸດປະສົງທີ່ແຕກຕ່າງກັນ.

ໂດຍສະເພາະ ກົດລະບຽບ
target1 target2: dependency1 dependency2...
ການ​ປະ​ຕິ​ບັດ​ທີ່​ຈະ​ປະ​ຕິ​ບັດ​

syntax ນີ້ກໍານົດວ່າເພື່ອເຮັດໃຫ້ບໍ່ວ່າຈະ ເປົ້າ ໝາຍ ທີ 1 or ເປົ້າ ໝາຍ ທີ 2, ໄຟລ໌ທັງຫມົດ
ເພິ່ງພາອາໄສ1, ເພິ່ງພາອາໄສ2, ແລະອື່ນໆ, ຕ້ອງໄດ້ຮັບການເຮັດແລ້ວ. ຫຼັງຈາກນັ້ນ, ການປະຕິບັດທີ່ໄດ້ມອບໃຫ້
ປະຕິບັດໂດຍຫອຍເພື່ອເຮັດໃຫ້ເປົ້າຫມາຍດັ່ງກ່າວ.

ກົດລະບຽບທໍາອິດທີ່ຊັດເຈນໃນໄຟລ໌ແມ່ນເປົ້າຫມາຍເລີ່ມຕົ້ນ, ແລະຖືກສ້າງຂື້ນຖ້າທ່ານບໍ່ລະບຸ
ເປົ້າ​ຫມາຍ​ໃດ​ຫນຶ່ງ​ໃນ​ບັນ​ຊີ​ຄໍາ​ສັ່ງ​.

ບໍ່ເຫມືອນກັບໂຄງການສ້າງແບບດັ້ງເດີມ, makepp ມັກຈະສົມມຸດວ່າການຮຽກຮ້ອງອັນຫນຶ່ງຂອງການປະຕິບັດ
ເຮັດໃຫ້ເປົ້າຫມາຍທັງຫມົດ (ເວັ້ນເສຍແຕ່ວ່າບໍ່ມີການເພິ່ງພາອາໄສ). ສໍາລັບຕົວຢ່າງ, ຫນຶ່ງ invocation
ຂອງ yacc ສ້າງໄຟລ໌ຜົນຜະລິດທັງສອງສໍາລັບກົດລະບຽບນີ້:

y.tab.c y.tab.h : parser.y
$(YACC) -d parser.y

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

· ການປະຕິບັດກົດລະບຽບກ່າວເຖິງຕົວແປອັດຕະໂນມັດ $@. (ຄໍາສັບຄ້າຍຄື "$(output)" ຫຼື
"$(ເປົ້າໝາຍ)" ບໍ່ໃຫ້ເກີດພຶດຕິກຳນີ້.)

· ການປະຕິບັດກົດລະບຽບບໍ່ໄດ້ກ່າວເຖິງຕົວແປອັດຕະໂນມັດ "$(outputs)" (ຫຼືຄໍາສັບຄ້າຍຄືຂອງມັນ
"$(ເປົ້າໝາຍ)").

· ນີ້​ບໍ່​ແມ່ນ​ກົດ​ລະ​ບຽບ​ຮູບ​ແບບ​, ແລະ​ບໍ່​ມີ foreach clause​.

ຍົກ​ຕົວ​ຢ່າງ,

ການ​ຕິດ​ຕັ້ງ​ການ​ທົດ​ສອບ​ທັງ​ຫມົດ​:
ສໍາລັບ subdir ໃນ $(SUBDIRS); ເຮັດ cd $$subdir && $(MAKE) $@; cd..; ສຳເລັດແລ້ວ

ເປັນ idiom ທົ່ວໄປໃນ makefiles, ແລະ makepp ສະຫນັບສະຫນູນມັນ. (ໃຫ້ສັງເກດວ່າທ່ານບໍ່ຄວນໃຊ້
recursive make ໃນ makefiles ໃຫມ່ໃດໆທີ່ທ່ານຂຽນ - ໃຊ້ "load_makefile" ຄໍາຖະແຫຼງການ, ຫຼື
ການໂຫຼດ makefile implicit ແທນ.)

ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະມີກົດລະບຽບດຽວກັນປະຕິບັດຫນຶ່ງຄັ້ງສໍາລັບແຕ່ລະເປົ້າຫມາຍ (ຕົວຢ່າງ, ເນື່ອງຈາກວ່າເປົ້າຫມາຍ
ມີຄໍາສັ່ງທີ່ຄ້າຍຄືກັນ), ມັນມັກໃຊ້ກົດລະບຽບຮູບແບບ (ເບິ່ງຂ້າງລຸ່ມນີ້) ຫຼື a
ຂໍ້ “foreach”. ຕົວຢ່າງ, ຖ້າມີໂຄງການສ້າງແບບດັ້ງເດີມ, ເຈົ້າຈະຂຽນ:

ກ​ຂ​ຄ​ງ:
do_something to build $@ > $@

ໃນ makepp, ທ່ານອາດຈະຕ້ອງການຂຽນມັນແບບນີ້:

$(foreach): : foreach abcd
do_something ເພື່ອສ້າງ $(output) > $(output)

ໂຟນີ ເປົ້າຫມາຍ

A phony ເປົ້າ​ຫມາຍ ແມ່ນເປົ້າຫມາຍທີ່ຈະບໍ່ເຄີຍມີຢູ່ໃນລະບົບໄຟລ໌; ມັນພຽງແຕ່ເປັນ
ວິທີການຮັບ makepp ເພື່ອສ້າງບາງເປົ້າຫມາຍແລະອາດຈະປະຕິບັດບາງຄໍາສັ່ງເພີ່ມເຕີມ.

ເປົ້າຫມາຍ phony ປົກກະຕິແມ່ນ "ທັງຫມົດ", ເຊິ່ງປົກກະຕິແລ້ວແມ່ນໃຊ້ເພື່ອເຮັດໃຫ້ທຸກສິ່ງທຸກຢ່າງທີ່ເປັນໄປໄດ້
ການ​ກໍ່​ສ້າງ​ທີ່​ຈະ​ກໍ່​ສ້າງ​, ດັ່ງ​ນີ້​:

ທັງໝົດ: prog1 prog2 subdir/prog3 subdir2/libmine.a
@&echo "ສຳເລັດແລ້ວ!"

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

ເພື່ອຮັກສາ makepp ຈາກການຄາດຫວັງໄຟລ໌ ./ທັງໝົດ ການ​ອອກ​, ທ່ານ​ຈໍາ​ເປັນ​ຕ້ອງ​ບອກ​ວ່າ​ມັນ​ເປັນ​
ເປົ້າ​ຫມາຍ phony. ພຽງແຕ່ໃສ່ເສັ້ນເຊັ່ນຕໍ່ໄປນີ້ໃນ makefile ຂອງທ່ານ (ມັນບໍ່ມີຄວາມແຕກຕ່າງ
ບ່ອນທີ່):

.PHONY: ທັງຫມົດ

ທາງເລືອກທີ່ທຽບເທົ່າທີ່ບາງຄັ້ງສະດວກກວ່າແມ່ນການໃຊ້ "$(phony)"
ຫນ້າ​ທີ່​ເຊັ່ນ​ນີ້​:

$(phony all): prog1 prog2 subdir/prog3 subdir2/libmine.a

ເປົ້າຫມາຍ phony ໃນ makefile ຫນຶ່ງສາມາດຫມາຍເຖິງເປົ້າຫມາຍ phony ໃນ makefile ອື່ນ. ນີ້​ແມ່ນ
ມັກຈະເຮັດດ້ວຍເປົ້າຫມາຍ "ສະອາດ", ເຊັ່ນນີ້:

# makefile ລະດັບສູງສຸດ:
# ກົດລະບຽບແລະສິ່ງຫຼາຍຢ່າງຢູ່ທີ່ນີ້
#....
$(phony clean): subdir1/clean subdir2/clean
&rm -fm my_program

ຫຼັງຈາກນັ້ນ, ໃນໄດເລກະທໍລີຍ່ອຍ, makefiles ອາດຈະອ່ານເຊັ່ນນີ້:

# Makefile ໃນໄດເລກະທໍລີຍ່ອຍ
#...
$(ລ້າງ​ຜິດ​ພາດ):
&rm -fm $(wildcard *.o *.a)

ແຕ່ໃນປັດຈຸບັນທ່ານຈະໃຊ້ຄໍາສັ່ງ "makeppclean", ແທນທີ່ຈະເປັນເປົ້າຫມາຍທີ່ສະອາດ.

ຕົວແທນ

ມັນປອດໄພທີ່ຈະລະບຸ wildcards ໃນບັນຊີລາຍຊື່ການເພິ່ງພາອາໄສ. ຕົວແທນທີ່ກົງກັນບໍ່ພຽງແຕ່ໄຟລ໌ເທົ່ານັ້ນ
ທີ່ມີຢູ່, ແຕ່ໄຟລ໌ທີ່ສາມາດສ້າງໄດ້ຕາມກົດລະບຽບໃນ makefile. ຍົກ​ຕົວ​ຢ່າງ,
ເພື່ອສ້າງຫ້ອງສະຫມຸດຈາກໄຟລ໌ .o ທັງຫມົດໃນໄດເລກະທໍລີ, ທ່ານສາມາດຂຽນນີ້:

libmine.a: *.o
&rm -f $(ຜົນຜະລິດ)
ar cr $(output) $(inputs)

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

Makepp ສະຫນັບສະຫນູນທັງຫມົດ shell wildcards ປົກກະຕິ ("*", "?", ແລະ "[]"). ມັນຍັງມີ a
wildcard "**" ເຊິ່ງກົງກັບຈໍານວນຂອງໄດເລກະທໍລີທີ່ແຊກແຊງໃດໆ. (ຄວາມຄິດນີ້ຖືກລັກ
ຈາກ zsh.) ຕົວຢ່າງ, "**/*.c" ກົງກັບທັງໝົດ .c ໄຟລ໌ໃນຕົ້ນໄມ້ແຫຼ່ງທັງຫມົດ.
"objects/**/*.o" ກົງກັບທັງໝົດ .o ໄຟລ໌ທີ່ບັນຈຸຢູ່ບ່ອນໃດກໍໄດ້ຢູ່ໃນໄດເລກະທໍລີຍ່ອຍ ວັດຖຸ
ຫຼື ໄດເລກະທໍລີຍ່ອຍ ຫຼື ໄດເລກະທໍລີຍ່ອຍຂອງມັນ. ສັນຍາລັກ "**" ຈະບໍ່ເປັນ
ປະຕິບັດຕາມການເຊື່ອມຕໍ່ອ່ອນໆໄປຫາໄດເລກະທໍລີໃນລະດັບໃດກໍ່ຕາມ. ມັນຍັງຈະບໍ່ສົ່ງຄືນເປົ້າໝາຍທີ່ຫຼອກລວງ.

ຕົວແທນຂອງ Makepp ຈະບໍ່ສົນໃຈໄຟລ໌ ຫຼືໄດເລກະທໍລີທີ່ມີຢູ່ ແຕ່ບໍ່ສາມາດອ່ານໄດ້. ຫຼັງຈາກ
ທັງຫມົດ, ໄຟລ໌ດັ່ງກ່າວບໍ່ສາມາດຖືກນໍາໃຊ້ໃນຂະບວນການກໍ່ສ້າງຢ່າງໃດກໍ່ຕາມ. ການວາງໄຟລ໌ທີ່ບໍ່ສາມາດອ່ານໄດ້ໃນ a
ໄດເລກະທໍລີແມ່ນເປັນປະໂຫຍດຕົ້ນຕໍເພື່ອຍັບຍັ້ງການນໍາເຂົ້າອັດຕະໂນມັດຂອງໄຟລ໌ທີ່ໃຫ້ມາຈາກ a
repository

ການຢືນຢັນໃນເບື້ອງຕົ້ນແມ່ນວ່ານີ້ແມ່ນປອດໄພ. ນີ້ແມ່ນຢູ່ໃນເຫດຜົນທີ່ວ່າມັນເຮັດວຽກບໍ່ວ່າຈະເປັນ
ໄຟລ໌ມີຢູ່ແລ້ວ, ຫຼືຕ້ອງການສ້າງກ່ອນ. ຢ່າງໃດກໍຕາມ, ມັນບໍ່ປອດໄພໃນຄວາມຮູ້ສຶກ
ວ່າມັນຈະຍັງກົງກັບໄຟລ໌ທີ່ສ້າງຂຶ້ນໂດຍ makepp, ແຕ່ບໍ່ມີກົດລະບຽບອີກຕໍ່ໄປ (ຕົວຢ່າງ
ທ່ານເອົາອອກ .c ໄຟລ໌, ແຕ່ .o ໄຟລ໌ຍັງມີຢູ່.) ເພື່ອປ້ອງກັນອັນນີ້, ໃຫ້ໃຊ້
ທາງເລືອກ "--rm-stale".

ຮູບແບບ ກົດລະບຽບ
ກົດລະບຽບຮູບແບບແມ່ນກົດລະບຽບທີ່ຖືກນໍາໃຊ້ໂດຍອີງໃສ່ຮູບແບບຂໍ້ຄວາມບາງຢ່າງ. ນີ້ຖືກນໍາໃຊ້ເພື່ອ
ໃຊ້ກົດລະບຽບດຽວກັນກັບໄຟລ໌ທັງຫມົດ. syntax ແມ່ນຄືກັນກັບ GNU make's
ກົດ​ລະ​ບຽບ​ຮູບ​ແບບ​:

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

ນີ້ບອກວ່າໄຟລ໌ໃດໆໃນໄດເລກະທໍລີປະຈຸບັນທີ່ກົງກັບ "*.c" ສາມາດຖືກປ່ຽນເປັນ
ໄຟລ໌ .o ທີ່ສອດຄ້ອງກັນໂດຍໃຊ້ຄໍາສັ່ງທີ່ໃຫ້.

ກະລຸນາຮັບຊາບວ່າການຂຶ້ນກັບຮູບແບບຫຼາຍອັນອາດຈະຖືກສະໜອງໃຫ້. ຕົວຢ່າງ, ຖ້າເຈົ້າ xyz.o ເອກະສານ
ຂຶ້ນກັບທີ່ສອດຄ້ອງກັນ xyz.cpp ໄຟລ໌, ແລະຍັງຢູ່ໃນໄຟລ໌ທີ່ເອີ້ນວ່າ moc_xyz.cflags ທີ່
ປະກອບມີທາງເລືອກໃນການລວບລວມຂໍ້ມູນ, ນີ້ສາມາດສະແດງອອກດ້ວຍ:

%.o: %.cpp %.cflags
$(CXX) `cat $(stem).cflags` -c $(inputs) -o $(output)

ທ່ານອາດຈະມີເປົ້າໝາຍຮູບແບບຫຼາຍອັນ. ຍົກ​ຕົວ​ຢ່າງ,

%.tab.h %.tab.c : %.y
yacc -d $(ປ້ອນຂໍ້ມູນ)
&mv y.tab.h $(stem).tab.h
&mv y.tab.c $(stem).tab.c

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

makepp_percent_subdir := 1

ກ່ອນກົດລະບຽບຮູບແບບທໍາອິດໃນ makefile ຂອງທ່ານຫຼືຢູ່ໃນເສັ້ນຄໍາສັ່ງສໍາລັບຕົວຢ່າງ.

ມີຄວາມແຕກຕ່າງກັນຢ່າງຊັດເຈນລະຫວ່າງ "%" ແລະຕົວແທນ "*", ເຖິງແມ່ນວ່າທັງສອງຈະກົງກັນ
string: ສັນຍາລັກແທນທີ່ສົ່ງຄືນບັນຊີລາຍຊື່ຂອງໄຟລ໌ທີ່ຖືກນໍາໃຊ້ຢ່າງສົມບູນໃນຈຸດນັ້ນ. ດັ່ງນັ້ນ
ນີ້ແມ່ນຂຶ້ນກັບທັງຫມົດ .o ໄຟລ໌ສາມາດສ້າງໄດ້ທີ່ນີ້:

prog: *.o
$(LD) $(LDFLAGS) $(inputs) -o $(output)

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

static ຮູບແບບ ກົດລະບຽບ
ກົດລະບຽບຮູບແບບຄົງທີ່ແມ່ນກົດລະບຽບຮູບແບບທີ່ຖືກນໍາໃຊ້ກັບຊຸດໄຟລ໌ທີ່ຈໍາກັດເທົ່ານັ້ນ:

$(SPECIAL_MODULES).o : %.o : %.cpp
$(CXX) -c $(input) -o $(output)

ນີ້ບອກວ່າກົດລະບຽບຮູບແບບໃຊ້ກັບໄຟລ໌ໃນ "$(SPECIAL_MODULES).o".

ນີ້ແມ່ນສ່ວນໃຫຍ່ແມ່ນສໍາລັບການເຂົ້າກັນໄດ້ກັບ GNU ເຮັດໃຫ້; ກົດລະບຽບຂອງ foreach (ເບິ່ງຂ້າງລຸ່ມນີ້) ແມ່ນເພີ່ມເຕີມ
ວິທີການທີ່ມີປະສິດທິພາບໃນການເຮັດສິ່ງດຽວກັນ.

ຄາດລ່ວງ ໜ້າ ກົດລະບຽບ
syntax ຮູບແບບຂ້າງເທິງແມ່ນມີອໍານາດພຽງພໍທີ່ຈະສະຫນັບສະຫນູນການກໍ່ສ້າງເກືອບທັງຫມົດ, ແຕ່
ບາງຄັ້ງມັນຈໍາເປັນຕ້ອງເຮັດບາງສິ່ງບາງຢ່າງທີ່ສັບສົນຫຼາຍ. Makepp ສະຫນອງເພີ່ມເຕີມ
syntax ທີ່ມີປະສິດທິພາບ: ປະໂຫຍກ ":foreach" ສໍາລັບກົດລະບຽບ.

target_expression : dependency_expression : foreach file-list
ຫຸ້ນ

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

#ນີ້ຄືກົດເກນທີ່ໃຊ້ໄດ້ກັບທຸກຢ່າງ:
%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

%.o : %.c : foreach $(SPECIAL_MODULES)
$(CC) $(SPECIAL_CFLAGS) -c $(input) -o $(output)

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

ນີ້ແມ່ນ syntax unwieldy ແຕ່ມັນມີຄວາມຍືດຫຍຸ່ນທີ່ສຸດ, ເພາະວ່າຕົວແປ "$(foreach)"
ອາດຈະປາກົດໃນທາງໃດກໍ່ຕາມໃນການສະແດງ. ກ່ອນອື່ນ ໝົດ, ໃຫ້ສັງເກດວ່າກົດລະບຽບຮູບແບບແມ່ນໃນຄວາມເປັນຈິງ a
ກໍລະນີພິເສດຂອງກົດລະບຽບ foreach; ກົດ​ລະ​ບຽບ​ຮູບ​ແບບ​

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

ເທົ່າກັບ:

$(patsubst %.c, %.o, $(foreach)): $(foreach): foreach *.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

(ໃນ​ຄວາມ​ເປັນ​ຈິງ, ມັນ​ໄດ້​ຖືກ​ປ່ຽນ​ເປັນ​ປະ​ມານ​ທີ່​ຢູ່​ພາຍ​ໃນ.)

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

# ກົດລະບຽບສຳລັບໄຟລ໌ .c ທຳມະດາ:
%.o : %.c
$(CC) $(CFLAGS) -c $(input) -o $(output)

# ກົດລະບຽບການສ້າງໄຟລ໌ .c ຈາກໄຟລ໌ .k:
%.c : %.k
$(preprocessor) $(input) > $(output)

# ກົດລະບຽບການສ້າງພິເສດສໍາລັບໄຟລ໌ .c ທີ່ສ້າງຂຶ້ນຈາກໄຟລ໌ .k:
$(foreach:%.k=%.o): $(foreach:%.c=%.k): foreach *.k
$(CC) $(SPECIAL_CFLAGS) -c $(input) -o $(output)

(ນີ້ໃຊ້ syntax ອ້າງອີງການທົດແທນທີ່ຫຍໍ້ເລັກນ້ອຍກວ່າການໂທຫາ
"patsubst" ຢ່າງຊັດເຈນ.)

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

Legacy បច្ច័យ ກົດລະບຽບ
ສໍາລັບຄວາມເຂົ້າກັນໄດ້ໃນດ້ານຫລັງ, makepp ສະຫນັບສະຫນູນກົດລະບຽບການຕໍ່ທ້າຍແບບເກົ່າ.

.suffix1.suffix2:
ຫຸ້ນ

ເທົ່າກັບ

%.suffix2: %.suffix1
ຫຸ້ນ

ແຕ່ຫຼາຍຍາກທີ່ຈະຈື່. (ຄຳຕໍ່ທ້າຍອັນໃດມາກ່ອນ?) ໂດຍປົກກະຕິ, ກົດລະບຽບຈະປາກົດຂຶ້ນ
ໃນ makefile ມໍລະດົກເຊັ່ນນີ້:

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

ເຊິ່ງແມ່ນແທ້ທຽບເທົ່າກັບ

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

ການຂັດຂືນ ກົດລະບຽບ
ເມື່ອມີຫຼາຍກວ່າຫນຶ່ງວິທີທີ່ຈະເຮັດໃຫ້ໄຟລ໌, makepp ໃຊ້ຂັ້ນຕອນງ່າຍໆເພື່ອ
ກໍານົດກົດລະບຽບທີ່ຈະນໍາໃຊ້.

· ມັນເປັນຄວາມຜິດພາດທີ່ຈະມີກົດລະບຽບທີ່ຊັດເຈນທີ່ຂັດແຍ້ງກັນໃນການສ້າງໄຟລ໌.

· ກົດລະບຽບຮູບແບບ ແລະກົດລະບຽບຂອງ foreach ທີ່ມີ wildcards ບໍ່ເຄີຍ override ກົດລະບຽບທີ່ຈະແຈ້ງ. ດັ່ງນັ້ນ
ກົດລະບຽບທີ່ຊັດເຈນສາມາດຖືກນໍາໃຊ້ເພື່ອກໍານົດຂໍ້ຍົກເວັ້ນສໍາລັບກົດລະບຽບຮູບແບບ. (ໃຫ້ສັງເກດວ່າງ່າຍໆ
ການໃຊ້ປະໂຫຍກ ":foreach" ບໍ່ໄດ້ເຮັດໃຫ້ບາງສິ່ງບາງຢ່າງເປັນກົດລະບຽບຮູບແບບ. ມັນຕ້ອງມີ a
wildcard (ເຊັ່ນ "*" ຫຼື "?") ເປັນສ່ວນຫນຶ່ງຂອງຊື່ໄຟລ໌ໃນປະໂຫຍກ ":foreach". ຖ້າມັນເປັນ
ພຽງແຕ່ບັນຊີລາຍຊື່ທີ່ຊັດເຈນຂອງໄຟລ໌, ມັນຖືກປະຕິບັດເປັນກົດລະບຽບທີ່ຊັດເຈນສໍາລັບແຕ່ລະຄົນ
ໄຟລ໌.)

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

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

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

ແລະທ່ານສາມາດມີ makefile ໃນຫນຶ່ງຂອງ subdirectories ທີ່ເວົ້າວ່າ:

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

· ກົດລະບຽບຮູບແບບທີ່ມີລະບົບຕ່ອງໂສ້ການອະນຸມານສັ້ນກວ່າແມ່ນມັກຫຼາຍກວ່າຮູບແບບອື່ນໆ
ກົດລະບຽບ. ຕົວຢ່າງ, ຖ້າທ່ານມີກົດລະບຽບຕໍ່ໄປນີ້ (ອີງໃສ່ຕົວຢ່າງຈາກ
Linux kernel):

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

%.o: %.s
$(AS) $(input) -o $(output)

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

ຖ້າພວກເຮົາຕ້ອງການສ້າງ "xyz.o", ພວກເຮົາສາມາດສ້າງໄຟລ໌ ".s" ລະດັບປານກາງແລະຫຼັງຈາກນັ້ນ
ແລ່ນຜ່ານຕົວປະກອບໂດຍໃຊ້ສອງກົດ ທຳ ອິດ, ຫຼືພວກເຮົາສາມາດໄປຫາ a
ໄຟລ໌ ".o" ໂດຍໃຊ້ກົດລະບຽບສຸດທ້າຍ. ກົດລະບຽບສຸດທ້າຍແມ່ນມັກເພາະວ່າມີຫນ້ອຍ
ຂັ້ນ ຕອນ ໃນ ລະ ບົບ ຕ່ອງ ໂສ້ ຂອງ inference (ຫນຶ່ງ ແທນ ທີ່ ຈະ ເປັນ ສອງ).

· ກົດລະບຽບຮູບແບບຕໍ່ມາໃນ makefile override ກົດລະບຽບຮູບແບບທີ່ກ່ອນຫນ້ານີ້. (ນີ້​ແມ່ນ
ກັບຄືນໄປບ່ອນຈາກ GNU ເຮັດໃຫ້.) ນີ້ຫມາຍຄວາມວ່າທ່ານຄວນວາງກົດລະບຽບທົ່ວໄປຂອງທ່ານ
ກ່ອນຫນ້ານີ້, ແລະກົດລະບຽບສະເພາະຂອງທ່ານຕໍ່ມາ. ຍົກ​ຕົວ​ຢ່າງ,

%o: %c # ກົດລະບຽບການລວບລວມຂໍ້ມູນທົ່ວໄປ.
ການປະຕິບັດ

special_%.o: special_%.c # ກົດລະບຽບພິເສດສໍາລັບໄຟລ໌ທີ່ມີ a
ການປະຕິບັດທີ່ແຕກຕ່າງກັນ # "special_" ຄໍານໍາຫນ້າ.

ກົດລະບຽບ ທາງເລືອກໃນການ
ບາງຄັ້ງມັນຈໍາເປັນຕ້ອງສະຫນອງທາງເລືອກເພີ່ມເຕີມເພື່ອດັດແປງວິທີການ makepp ປະຕິບັດ
ກົດລະບຽບ. ຕົວເລືອກເຫຼົ່ານີ້ຖືກລະບຸເປັນ ":optionname value", ບໍ່ວ່າຈະຢູ່ໃນແຖວທີ່ມີ
ການເພິ່ງພາອາໄສ, ຫຼືໃນແຖວຕໍ່ໄປ.

ການສະຫນອງທາງເລືອກໃນສາຍແຍກຕ່າງຫາກອາດຈະເຮັດໃຫ້ມັນເປັນໄປໄດ້ສໍາລັບທ່ານທີ່ຈະນໍາໃຊ້ດຽວກັນ
makefile ກັບ makepp ແລະເຮັດແບບດັ້ງເດີມ. ຍົກ​ຕົວ​ຢ່າງ,

ເປົ້າໝາຍ : ການເພິ່ງພາອາໄສ
: ລາຍເຊັນ target_newer
ຫຸ້ນ

ຈະເຮັດວຽກໄດ້ດີກັບ Unix ແບບດັ້ງເດີມ, ເພາະວ່າມັນຕີຄວາມຫມາຍເສັ້ນ ": ລາຍເຊັນ".
ເປັນຄໍາສັ່ງແກະ, ແລະຄໍາສັ່ງເລີ່ມຕົ້ນດ້ວຍຈໍ້າສອງເມັດບໍ່ເຮັດຫຍັງເລີຍ.

:build_cache /path/to/build/cache
ເປົ້າໝາຍ : ການເພິ່ງພາອາໄສ
: build_cache /put/cache/files/over/there
ຫຸ້ນ

ລະບຸເສັ້ນທາງໄປຫາ build cache ທີ່ຈະໃຊ້ສໍາລັບໄຟລ໌ທີ່ຜະລິດໂດຍກົດລະບຽບນີ້. ນີ້
overrides ຜົນກະທົບຂອງຄໍາສັ່ງ "build_cache" ຫຼືຄໍາສັ່ງ "--build-cache".
ທາງເລືອກແຖວ, ຖ້າມີ, ສໍາລັບກົດລະບຽບນີ້. ເບິ່ງ makepp_build_cache ສໍາລັບລາຍລະອຽດກ່ຽວກັບການກໍ່ສ້າງ
ແຄສ.

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

:build_check build_check_method
ເປົ້າໝາຍ : ການເພິ່ງພາອາໄສ
: build_check target_newer
ຫຸ້ນ

ອັນນີ້ບອກ makepp ວ່າຈະໃຊ້ວິທີໃດເພື່ອຕັດສິນໃຈວ່າເປົ້າໝາຍຕ້ອງຖືກສ້າງໃໝ່ຫຼືບໍ່.
ເບິ່ງ makepp_build_check ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ. ນີ້ overrides ຜົນກະທົບຂອງ
ຄໍາສັ່ງ "build_check" ຫຼື "--build-check-method" ທາງເລືອກແຖວຄໍາສັ່ງ, ຖ້າມີ, ສໍາລັບ
ກົດ​ລະ​ບຽບ​ນີ້​.

:env ຄວາມເປັນໄປໄດ້ ...
ເພີ່ມການຂຶ້ນກັບຄ່າຂອງຕົວແປສະພາບແວດລ້ອມທີ່ມີຊື່. ຖ້າ​ຫາກ​ວ່າ​ໃດໆ​ຂອງ​ເຂົາ​ເຈົ້າ​
ແຕກຕ່າງຈາກການກໍ່ສ້າງທີ່ຜ່ານມາ, ຫຼັງຈາກນັ້ນ, ເປົ້າຫມາຍແມ່ນຖືວ່າລ້າສະໄຫມ, ຖ້າ
build_check method ນັ້ນ dictates. (ທັງຫມົດຂອງການກໍ່ສ້າງໃນການກໍ່ສ້າງວິທີການກວດສອບຍົກເວັ້ນສໍາລັບ
target_newer ເຄົາລົບອັນນີ້.)

VARIABLE ອາດຈະຢູ່ໃນຮູບແບບ "ຊື່ໄຟລ໌ໃນ PATH_VARIABLE" (ໃນວົງຢືມ), ໃນກໍລະນີນີ້
ເປົ້າໝາຍຖືກພິຈາລະນາວ່າລ້າສະໄໝ ຖ້າໄດເຣັກທໍຣີທຳອິດຈາກເຄື່ອງໝາຍຈໍ້າສອງເມັດ
ຄ່າຂອງ PATH_VARIABLE ເຊິ່ງມີຊື່ໄຟລ໌ແຕກຕ່າງຈາກການສ້າງຫຼ້າສຸດ.
ນີ້ສາມາດຖືກນໍາໃຊ້ເພື່ອຫຼີກເວັ້ນການສ້າງເປົ້າຫມາຍໃຫມ່ເມື່ອ PATH_VARIABLE ມີການປ່ຽນແປງໃນ
ວິທີການທີ່ບໍ່ກ່ຽວຂ້ອງ.

: ຈັດສົ່ງ ຄໍາສັ່ງ ...
ຄັດຕິດແຕ່ລະການກະທຳຂອງແກະ (ແຕ່ບໍ່ແມ່ນຄຳສັ່ງ Perl ຫຼືຄຳສັ່ງ Perl) ໃນ "sh -c '...'"
ແລະນໍາຫນ້າດ້ວຍຄໍາສັ່ງ, ແຕ່ສົມມຸດວ່າເປົ້າຫມາຍບໍ່ຂຶ້ນກັບຄໍາສັ່ງ.
ນີ້ແມ່ນເປັນປະໂຫຍດຖ້າທ່ານຕ້ອງການສົ່ງການປະຕິບັດກັບລະບົບການຈັດແຖວວຽກ, ແຕ່ຜົນໄດ້ຮັບແມ່ນ
ສົມມຸດວ່າເປັນເອກະລາດຂອງຕົວກໍານົດການຄິວ, ເຊັ່ນດຽວກັນກັບບໍ່ວ່າຈະເປັນແຖວ
ລະບົບໄດ້ຖືກນໍາໃຊ້ທັງຫມົດ.

:ລວມ file_or_pattern
ກົດລະບຽບແຕກຕ່າງກັນໄປຕາມ compiler:

%.o : %.c
: ລວມ %.d : ລາຍເຊັນ C
gcc -MD -c ...

%.o : %.c
: include %.u : ລາຍເຊັນ C# IBM ໃຊ້ຄຳຕໍ່ທ້າຍທີ່ແຕກຕ່າງ
xlc -M -c ...

sub dependify { # ປ່ຽນການສົນທະນາຂອງ Microsoft ໃຫ້ເປັນຮູບແບບທີ່ເປັນປະໂຫຍດ
s/\$/\$\$/g;
s/(ໝາຍເຫດ: ລວມທັງໄຟລ໌: *)?(.+?)\r?\n/$1 ? "'$2' " : "'".f_output()."': "/e;
}
%.o : %.c
: ລວມ %.d : ລາຍເຊັນ C
cl -showIncludes -c ... >$(stem).d
&sed &dependify -o +<$(stem).d

ບາງ compilers (icc ຂອງ Intel ຄືກັນກັບ gcc ຂ້າງເທິງ, ຫຼື IBM's xlc) ສາມາດຜະລິດ dependency.
ໄຟລ​໌​ໃນ​ການ​ບິນ​. ນັ້ນແມ່ນ, ໃນຂະນະທີ່ພວກເຂົາລວບລວມ, ພວກເຂົາຂຽນ makefile ທີ່ makepp ສາມາດເຮັດໄດ້
ລວມ. ປະໂຫຍດຫຼາຍກວ່າເຄື່ອງສະແກນຂອງ makepp ແມ່ນການຮັບປະກັນ 100%
ຖືກຕ້ອງ, ບ່ອນທີ່ພວກເຮົາພຽງແຕ່ເຂົ້າມາໃກ້.

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

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

ມີການຈັບໃນເວລາທີ່ທ່ານເອົາຄໍາຖະແຫຼງ "#include" ອອກ ແລະ ໄຟລ໌ທີ່ສອດຄ້ອງກັນ:
ມັນຈະຍັງຖືກກ່າວເຖິງຢູ່ໃນເອກະສານການເພິ່ງພາອາໄສຈາກຄັ້ງສຸດທ້າຍ, ເມື່ອມັນແມ່ນ
ຕ້ອງການ. ໃນກໍລະນີດັ່ງກ່າວ, ທ່ານຕ້ອງແກ້ໄຂໄຟລ໌ dependency ເພື່ອເອົາ dependency
ຊຶ່ງ​ບໍ່​ສາມາດ​ບັນລຸ​ໄດ້​ອີກ​ຕໍ່​ໄປ.

ຄຸນສົມບັດນີ້ບໍ່ສາມາດໃຊ້ກັບ build cache ໄດ້ເນື່ອງຈາກການດຶງໄຟລ໌ຈາກບ່ອນນັ້ນ
ຕ້ອງການຮູ້ທຸກຢ່າງກ່ຽວກັບໄຟລ໌. ແຕ່ໄຟລ໌ທີ່ເພິ່ງພາອາໄສແມ່ນຂຶ້ນກັບສິ່ງເຫຼົ່ານັ້ນ
ໄຟລ໌ makepp ຮຽນຮູ້ກ່ຽວກັບການອ່ານມັນ. ການຂື້ນກັບວົງວຽນດັ່ງກ່າວແມ່ນບໍ່ປົກກະຕິ
ເປັນໄປໄດ້ໃນລະບົບການກໍ່ສ້າງທີ່ເຊື່ອຖືໄດ້. ນີ້ແມ່ນຂໍ້ຍົກເວັ້ນເພາະວ່າຫຼັງຈາກການກໍ່ສ້າງໃຫມ່
ແລະການອ່ານໄຟລ໌ dependency ຄືນໃໝ່ທຸກຢ່າງແມ່ນຖືກຕ້ອງອີກຄັ້ງ.

ຖ້າທ່ານສ້າງຢູ່ໃນບ່ອນເກັບມ້ຽນຂອງທ່ານ, makepp ຈະເລືອກເອົາໄຟລ໌ທີ່ເພິ່ງພາອາໄສຈາກ
1 repository ທີ່ປະກອບດ້ວຍຫນຶ່ງ. ນີ້ແມ່ນແຕກຕ່າງຈາກໄຟລ໌ອື່ນໆ, ບ່ອນທີ່ມັນໃຊ້ເວລາທີ 1
ດ້ວຍລາຍເຊັນທີ່ຄາດໄວ້. ນີ້ແມ່ນດີກ່ວາສໍາລັບການກໍ່ສ້າງຖານຄວາມຈໍາ, ບ່ອນທີ່ຂາດແຄນ
ລາຍເຊັນ, ມັນບໍ່ສາມາດຊອກຫາໄຟລ໌ໄດ້.

:ໂອ​ກາດ​ສຸດ​ທ້າຍ
ເປີດໃຊ້ກົດລະບຽບເປີດ, ເຊັ່ນ:

%.foo foo%.bar: :last_chance
&ສຽງ $@ -o $@
&cp $(ຜົນໄດ້ຮັບ)

ເນື່ອງຈາກວ່າກົດລະບຽບດັ່ງກ່າວສາມາດສ້າງຈໍານວນເປົ້າຫມາຍທີ່ບໍ່ມີຂອບເຂດທີ່ຈໍາເປັນ,
ເປົ້າໝາຍຂອງກົດລະບຽບນີ້ຈະບໍ່ກົງກັບຟັງຊັນ $(wildcard) ຫຼືກົດລະບຽບຮູບແບບເວັ້ນເສຍແຕ່
ບາງສິ່ງບາງຢ່າງອື່ນໄດ້ຍົກຕົວຢ່າງກົດລະບຽບໂດຍການອ້າງອີງເປົ້າຫມາຍໂດຍສະເພາະ.
ນອກຈາກນັ້ນ, ຖ້າ "--rm-stale" ຖືກລະບຸ, ຫຼັງຈາກນັ້ນເປົ້າຫມາຍທີ່ເຫລືອຈາກທີ່ຜ່ານມາ
makepp run ຈະປາກົດວ່າ stale ຖ້າວິທີດຽວທີ່ຈະສ້າງມັນແມ່ນຜ່ານກົດລະບຽບສຸດທ້າຍ
ທີ່ຍັງບໍ່ທັນໄດ້ຍົກຕົວຢ່າງສໍາລັບເປົ້າຫມາຍເທື່ອ, ຊຶ່ງເປັນພຶດຕິກໍາທີ່ຕ້ອງການເພາະວ່າ
ການ​ກໍ່​ສ້າງ​ຈະ​ລົ້ມ​ເຫຼວ​ຫຼາຍ​ສະ​ຫມໍ່າ​ສະ​ເຫມີ​ໃນ​ເວ​ລາ​ທີ່​ມັນ erroneously ອີງ​ໃສ່​ຕົວ​ແທນ​ທີ່​ຈະ​
ຈັບຄູ່ເປົ້າໝາຍຈາກການແລ່ນກ່ອນໜ້າ.

ທາງເລືອກ ":last_chance" ມີຈຸດປະສົງເພື່ອຮຽກຮ້ອງຄວາມສົນໃຈຕໍ່ກັບພຶດຕິກໍາພິເສດຂອງ
ກົດລະບຽບກ່ຽວກັບການຈັບຄູ່ wildcards.

:parser ແມ່ບົດ
ນີ້ບອກ makepp ວິທີການແຍກຄໍາສັ່ງສໍາລັບການກວດສອບ (ລວມທັງ) ໄຟລ໌. ປົກກະຕິແລ້ວ,
makepp ຄາດເດົາວິທີການເຮັດມັນໂດຍອີງໃສ່ຄໍາທີ່ຢູ່ໃນຄໍາສັ່ງຂອງມັນເອງ (ເບິ່ງ
makepp_scanning ສໍາລັບລາຍລະອຽດ). ຢ່າງໃດກໍຕາມ, ຖ້າ makepp ຄາດເດົາຜິດ, ທ່ານອາດຈະຕ້ອງການ
ຊີ້ບອກຕົວວິເຄາະຢ່າງຈະແຈ້ງ, ເຊັ່ນນີ້:

%.o: %.abc
: parser c_compilation
ການ​ປະ​ຕິ​ບັດ​ຢູ່​ທີ່​ນີ້​

ອັນນີ້ເຮັດໃຫ້ makepp ປະຕິບັດການແຍກ ແລະສະແກນແບບດຽວກັນກັບ C/C++
ກໍ່ສ້າງຄໍາສັ່ງ, ເຖິງແມ່ນວ່າມັນບໍ່ໄດ້ຮັບຮູ້ການປະຕິບັດເປັນການລວບລວມ C.

parser ເລີ່ມຕົ້ນແມ່ນຂຶ້ນກັບຄໍາສັ່ງ. ຖ້າທ່ານບໍ່ລະບຸຕົວເລືອກ ":parser",
ຫຼັງຈາກນັ້ນ, ຄໍາທໍາອິດຂອງແຕ່ລະຄໍາສັ່ງຖືກກວດສອບ. ຕົວຢ່າງສໍາລັບການລວບລວມຫຼືການເຊື່ອມຕໍ່
ຄໍາສັ່ງ, makepp ຈະໃຊ້ "c_compilation" parser; ຫຼືຖ້າຄໍາສັ່ງເບິ່ງຄືວ່າ
GNU variant, "gcc_compilation". ຖ້າບໍ່ພົບຕົວວິເຄາະ, ມັນໃຊ້ຕົວວິເຄາະ "none". ສໍາລັບ
ລາຍລະອຽດເພີ່ມເຕີມກ່ຽວກັບເລື່ອງນີ້, ຫຼືຖ້າທ່ານຕ້ອງການຂຽນ parser ຂອງທ່ານເອງຫຼືປ່ຽນ makepp's
ຕົວວິເຄາະເລີ່ມຕົ້ນ, ເບິ່ງ makepp_scanning.

ໃຫ້ສັງເກດວ່ານີ້ໃຊ້ກັບທຸກໆຄໍາສັ່ງໃນກົດລະບຽບ, ເຊິ່ງອາດຈະບໍ່ເປັນສິ່ງທີ່ທ່ານຕ້ອງການ:

%.o: %.c : parser c-compilation
@echo 'ການສ້າງ $(output)'
@funny_cc...

ນີ້ຍັງຈະຕີຄວາມຫມາຍ "echo" ເປັນ compiler ແລະ deduce ການໂຕ້ຖຽງຂອງຕົນ 'ການກໍ່ສ້າງ
mymodule.o' ເປັນການເພິ່ງພາອາໄສ implicit. ນີ້ຈະນໍາໄປສູ່ການຮ້ອງທຸກວ່າມັນ
ບໍ່ຮູ້ວິທີສ້າງໄຟລ໌ດັ່ງກ່າວ. ໃນກໍລະນີດັ່ງກ່າວນີ້, ທ່ານຈະດີກວ່າ
"register_parser". ຢູ່ທີ່ນັ້ນເຈົ້າຊອກຫາຄຳອະທິບາຍແນວໃດ ແມ່ບົດ ສາມາດໄດ້ຮັບການມອບໃຫ້ບໍ່ວ່າຈະເປັນ
classname ຫຼືຊື່ຟັງຊັນ.

:ລາຍເຊັນ signature_method
ເປົ້າໝາຍ : ການເພິ່ງພາອາໄສ
: ລາຍເຊັນ md5
ຫຸ້ນ

ອັນນີ້ບອກ makepp ວ່າຈະໃຊ້ອັນໃດອັນໜຶ່ງເພື່ອກຳນົດວ່າຄວາມເພິ່ງພາອາໄສໄດ້ປ່ຽນແປງຫຼືບໍ່.
ເບິ່ງ makepp_signatures ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມ. ວິທີການລາຍເຊັນທີ່ລວມຢູ່ໃນ
ການແຈກຢາຍ makepp ແມ່ນ "ທໍາມະດາ", "md5", "C" ຫຼື "c_compilation_md5", ແລະ.
"shared_object". ນີ້ແທນທີ່ວິທີການລາຍເຊັນທີ່ລະບຸໄວ້ດ້ວຍ "-m" ຫຼື
"--signature-method" ຕົວເລືອກແຖວຄໍາສັ່ງ, ຫຼືດ້ວຍຄໍາຖະແຫຼງ "ລາຍເຊັນ".

ພິເສດ ລັກສະນະ
Makepp ສາມາດສະຫນັບສະຫນູນຊື່ໄຟລ໌ທີ່ມີລັກສະນະພິເສດໃນພວກມັນເຊັ່ນ: ຈໍ້າສອງເມັດຫຼືຊ່ອງຫວ່າງ.
ສໍາລັບຕົວຢ່າງ, ທ່ານຕ້ອງການສ້າງໄຟລ໌ທີ່ເອີ້ນວ່າ "a:thing" ຈາກໄຟລ໌ "b:thing".
ທ່ານບໍ່ສາມາດຂຽນກົດລະບຽບດ້ວຍວິທີນີ້:

a:thing : b:thing # ນີ້ແມ່ນຂໍ້ຜິດພາດຂອງໄວຍະກອນ
&cat $(input) -o $(output)

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

"a:thing": "b:thing"
&cat $(input) -o $(output)

ໃນປັດຈຸບັນກົດລະບຽບແມ່ນບໍ່ແນ່ນອນ.

Syntax ວົງຢືມຂອງ Makepp ແມ່ນຂ້ອນຂ້າງຄ້າຍຄືກັນກັບ Shell's. ສໍາລັບຕົວຢ່າງ, ທ່ານສາມາດນໍາໃຊ້ດຽວ
quotes ແທນທີ່ຈະເປັນວົງຢືມຄູ່, ຫຼືທ່ານສາມາດຫນີຕົວອັກສອນພິເສດທີ່ມີ backslash:

a\:ສິ່ງ : 'b:thing'
&cat $(input) -o $(output)

ຕົວຢ່າງ, ສົມມຸດວ່າຊື່ໄຟລ໌ຂອງເຈົ້າແມ່ນ "'"!;\$". ດຽວນີ້ເປັນຫຍັງເຈົ້າຈຶ່ງຕ້ອງການຊື່ໄຟລ໌ດັ່ງກ່າວ.
ຂ້ອຍບໍ່ຮູ້, ແຕ່ນີ້ແມ່ນຫຼາຍວິທີທີ່ທ່ານສາມາດລະບຸມັນກັບ makepp (ແລະ shell):

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

ເອົາ ໃຈ ໃສ່ ກ່ຽວ ກັບ ເວ ລາ ທີ່ makepp strips quotes ແລະ ໃນ ເວ ລາ ທີ່ ແກະ ໄດ້. Makepp ເບິ່ງຢູ່
quotes ພຽງແຕ່ໃນກໍລະນີດັ່ງຕໍ່ໄປນີ້:

·ໃນຄອບຄົວ "ifeq" ຂອງການທົດສອບ

· ກ່ອນ ແລະ ຫຼັງ ຈໍ້າ ສອງ ເມັດ

·ໃນຄໍາສັ່ງສ້າງໃນ makepp

· ໃນ​ຫນ້າ​ທີ່​ທີ່​ກ່ຽວ​ຂ້ອງ​ກັບ​ໄຟລ​໌​

ບໍ່ຄືກັບແກະ, makepp ບໍ່ໄດ້ຂະຫຍາຍວົງຢືມໃນຂະນະທີ່ກໍານົດພວກມັນໃຫ້ກັບຕົວແປ. ດັ່ງນັ້ນ
ກົດລະບຽບຕໍ່ໄປນີ້ແມ່ນຄືກັນ:

FILE = 'ຊື່ທີ່ມີຍະຫວ່າງ'
x := $(ພິມ $(FILE)) # ພຽງແຕ່ເພື່ອກວດເບິ່ງວ່າວົງຢືມຍັງມີຢູ່
$(FILE): # ວົງຢືມປະມານໄຟລ໌ດຽວທີ່ຖອດອອກໂດຍ makepp
&echo hello -o$(FILE) # ວົງຢືມປະມານໄຟລ໌ດຽວທີ່ຖອດອອກໂດຍ makepp
ສະທ້ອນຢູ່ທີ່ນັ້ນ >>$(FILE) # ວົງຢືມປະມານໄຟລ໌ດຽວທີ່ຖືກຖອດອອກໂດຍ Shell
'ຊື່ທີ່ມີຍະຫວ່າງ':
&ສະທ້ອນສະບາຍດີ -o'name with spaces'
echo there >>'$(output)' # quotes has stripped above, add them again

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

$(ຟອກທັງໝົດ):
@&echo ນີ້ແມ່ນສັນຍາລັກເງິນໂດລາ: $$
@for val ໃນ abcd; ເຮັດສຽງສະທ້ອນ $$val; ສຳເລັດແລ້ວ

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

ເມື່ອຊື່ເປົ້າໝາຍ ຫຼືການເພິ່ງພາອາໄສຕົວແປອັດຕະໂນມັດເຊັ່ນ "$(output)", ຈາກນັ້ນ
ວົງຢືມ ແລະ backslashes ໃດຖືກຖອດອອກ. ນີ້ຫມາຍຄວາມວ່າຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະອ້າງອິງ
ຊື່ໄຟລ໌ໃນການປະຕິບັດ, ທ່ານອາດຈະຕ້ອງອ້າງເຖິງມັນອີກເທື່ອຫນຶ່ງ, ເຊັ່ນນີ້:

"ຊື່ໄຟລ໌ທີ່ມີຍະຫວ່າງ":
ສຽງສະທ້ອນ "ເນື້ອໃນພິເສດ" > "$@"

ຖ້າທ່ານບໍ່ໃສ່ວົງຢືມປະມານ $@, ຫຼັງຈາກນັ້ນ shell ຈະເຫັນຄໍາສັ່ງ

echo "ເນື້ອໃນພິເສດ" > ຊື່ໄຟລ໌ທີ່ມີຍະຫວ່າງ

ເຊິ່ງຂຽນຂໍ້ຄວາມ "ຊື່ໄຟລ໌ເນື້ອຫາພິເສດທີ່ມີຊ່ອງຫວ່າງ" ໃສ່ໄຟລ໌ທີ່ເອີ້ນວ່າ a.
ນີ້ອາດຈະບໍ່ແມ່ນສິ່ງທີ່ທ່ານຕ້ອງການ.

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